blob: c1823426f1855e9f40561fc4bc77e7b42683b135 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expression parsing implementation for C++.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattner500d3292009-01-29 05:15:15 +000014#include "clang/Parse/ParseDiagnostic.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000015#include "clang/Parse/Parser.h"
Douglas Gregorbc61bd82011-01-11 00:33:19 +000016#include "RAIIObjectsForParser.h"
Eli Friedmandc3b7232012-01-04 02:40:39 +000017#include "clang/Basic/PrettyStackTrace.h"
Richard Smith33762772012-03-08 23:06:02 +000018#include "clang/Lex/LiteralSupport.h"
John McCall19510852010-08-20 18:27:03 +000019#include "clang/Sema/DeclSpec.h"
Douglas Gregorae7902c2011-08-04 15:30:47 +000020#include "clang/Sema/Scope.h"
John McCall19510852010-08-20 18:27:03 +000021#include "clang/Sema/ParsedTemplate.h"
Douglas Gregor3f9a0562009-11-03 01:35:08 +000022#include "llvm/Support/ErrorHandling.h"
23
Reid Spencer5f016e22007-07-11 17:01:13 +000024using namespace clang;
25
Richard Smithea698b32011-04-14 21:45:45 +000026static 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:
David Blaikieb219cfc2011-09-23 05:06:16 +000034 llvm_unreachable("Unknown type for digraph error message.");
Richard Smithea698b32011-04-14 21:45:45 +000035 }
36}
37
38// Are the two tokens adjacent in the same source file?
Richard Smith19a27022012-06-18 06:11:04 +000039bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
Richard Smithea698b32011-04-14 21:45:45 +000040 SourceManager &SM = PP.getSourceManager();
41 SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
Argyrios Kyrtzidisa64ccef2011-09-19 20:40:19 +000042 SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
Richard Smithea698b32011-04-14 21:45:45 +000043 return FirstEnd == SM.getSpellingLoc(Second.getLocation());
44}
45
46// Suggest fixit for "<::" after a cast.
47static 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);
Argyrios Kyrtzidisa64ccef2011-09-19 20:40:19 +000063 ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
Richard Smithea698b32011-04-14 21:45:45 +000064 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
Richard Trieu950be712011-09-19 19:01:00 +000074// Check for '<::' which should be '< ::' instead of '[:' when following
75// a template name.
76void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
77 bool EnteringContext,
78 IdentifierInfo &II, CXXScopeSpec &SS) {
Richard Trieuc11030e2011-09-20 20:03:50 +000079 if (!Next.is(tok::l_square) || Next.getLength() != 2)
Richard Trieu950be712011-09-19 19:01:00 +000080 return;
81
82 Token SecondToken = GetLookAheadToken(2);
Richard Smith19a27022012-06-18 06:11:04 +000083 if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
Richard Trieu950be712011-09-19 19:01:00 +000084 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
Mike Stump1eb44332009-09-09 15:08:12 +000099/// \brief Parse global scope or nested-name-specifier if present.
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000100///
101/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
Mike Stump1eb44332009-09-09 15:08:12 +0000102/// may be preceded by '::'). Note that this routine will not parse ::new or
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000103/// ::delete; it will just leave them in the token stream.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000104///
105/// '::'[opt] nested-name-specifier
106/// '::'
107///
108/// nested-name-specifier:
109/// type-name '::'
110/// namespace-name '::'
111/// nested-name-specifier identifier '::'
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000112/// nested-name-specifier 'template'[opt] simple-template-id '::'
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000113///
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000114///
Mike Stump1eb44332009-09-09 15:08:12 +0000115/// \param SS the scope specifier that will be set to the parsed
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000116/// nested-name-specifier (or empty)
117///
Mike Stump1eb44332009-09-09 15:08:12 +0000118/// \param ObjectType if this nested-name-specifier is being parsed following
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000119/// 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///
Douglas Gregord4dca082010-02-24 18:44:31 +0000125/// \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
Douglas Gregorb10cd042010-02-21 18:36:56 +0000133/// member access expression, e.g., the \p T:: in \p p->T::m.
134///
John McCall9ba61662010-02-26 08:45:28 +0000135/// \returns true if there was an error parsing a scope specifier
Douglas Gregor495c35d2009-08-25 22:51:20 +0000136bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
John McCallb3d87482010-08-24 05:47:05 +0000137 ParsedType ObjectType,
Douglas Gregorb10cd042010-02-21 18:36:56 +0000138 bool EnteringContext,
Francois Pichet4147d302011-03-27 19:41:34 +0000139 bool *MayBePseudoDestructor,
140 bool IsTypename) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000141 assert(getLangOpts().CPlusPlus &&
Chris Lattner7452c6f2009-01-05 01:24:05 +0000142 "Call sites of this function should be guarded by checking for C++");
Mike Stump1eb44332009-09-09 15:08:12 +0000143
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000144 if (Tok.is(tok::annot_cxxscope)) {
Douglas Gregorc34348a2011-02-24 17:54:50 +0000145 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
146 Tok.getAnnotationRange(),
147 SS);
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000148 ConsumeToken();
John McCall9ba61662010-02-26 08:45:28 +0000149 return false;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000150 }
Chris Lattnere607e802009-01-04 21:14:15 +0000151
Douglas Gregor39a8de12009-02-25 19:37:18 +0000152 bool HasScopeSpecifier = false;
153
Chris Lattner5b454732009-01-05 03:55:46 +0000154 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;
Mike Stump1eb44332009-09-09 15:08:12 +0000159
Chris Lattner55a7cef2009-01-05 00:13:00 +0000160 // '::' - Global scope qualifier.
Douglas Gregor2e4c34a2011-02-24 00:17:56 +0000161 if (Actions.ActOnCXXGlobalScopeSpecifier(getCurScope(), ConsumeToken(), SS))
162 return true;
163
Douglas Gregor39a8de12009-02-25 19:37:18 +0000164 HasScopeSpecifier = true;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000165 }
166
Douglas Gregord4dca082010-02-24 18:44:31 +0000167 bool CheckForDestructor = false;
168 if (MayBePseudoDestructor && *MayBePseudoDestructor) {
169 CheckForDestructor = true;
170 *MayBePseudoDestructor = false;
171 }
172
David Blaikie42d6d0c2011-12-04 05:04:18 +0000173 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
Douglas Gregor39a8de12009-02-25 19:37:18 +0000189 while (true) {
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000190 if (HasScopeSpecifier) {
191 // C++ [basic.lookup.classref]p5:
192 // If the qualified-id has the form
Douglas Gregor3b6afbb2009-09-09 00:23:06 +0000193 //
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000194 // ::class-name-or-namespace-name::...
Douglas Gregor3b6afbb2009-09-09 00:23:06 +0000195 //
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000196 // 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.
John McCallb3d87482010-08-24 05:47:05 +0000201 ObjectType = ParsedType();
Douglas Gregor81b747b2009-09-17 21:32:03 +0000202
203 if (Tok.is(tok::code_completion)) {
204 // Code completion for a nested-name-specifier, where the code
205 // code completion token follows the '::'.
Douglas Gregor23c94db2010-07-02 17:43:08 +0000206 Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext);
Argyrios Kyrtzidisb6b2b182011-04-23 01:04:12 +0000207 // 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.
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +0000211 SS.setEndLoc(Tok.getLocation());
212 cutOffParsing();
213 return true;
Douglas Gregor81b747b2009-09-17 21:32:03 +0000214 }
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000215 }
Mike Stump1eb44332009-09-09 15:08:12 +0000216
Douglas Gregor39a8de12009-02-25 19:37:18 +0000217 // nested-name-specifier:
Chris Lattner77cf72a2009-06-26 03:47:46 +0000218 // 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)) {
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000223 // If we don't have a scope specifier or an object type, this isn't a
Eli Friedmaneab975d2009-08-29 04:08:08 +0000224 // nested-name-specifier, since they aren't allowed to start with
225 // 'template'.
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000226 if (!HasScopeSpecifier && !ObjectType)
Eli Friedmaneab975d2009-08-29 04:08:08 +0000227 break;
228
Douglas Gregor7bb87fc2009-11-11 16:39:34 +0000229 TentativeParsingAction TPA(*this);
Chris Lattner77cf72a2009-06-26 03:47:46 +0000230 SourceLocation TemplateKWLoc = ConsumeToken();
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000231
232 UnqualifiedId TemplateName;
233 if (Tok.is(tok::identifier)) {
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000234 // Consume the identifier.
Douglas Gregor7bb87fc2009-11-11 16:39:34 +0000235 TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000236 ConsumeToken();
237 } else if (Tok.is(tok::kw_operator)) {
238 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
Douglas Gregor7bb87fc2009-11-11 16:39:34 +0000239 TemplateName)) {
240 TPA.Commit();
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000241 break;
Douglas Gregor7bb87fc2009-11-11 16:39:34 +0000242 }
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000243
Sean Hunte6252d12009-11-28 08:58:14 +0000244 if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId &&
245 TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) {
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000246 Diag(TemplateName.getSourceRange().getBegin(),
247 diag::err_id_after_template_in_nested_name_spec)
248 << TemplateName.getSourceRange();
Douglas Gregor7bb87fc2009-11-11 16:39:34 +0000249 TPA.Commit();
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000250 break;
251 }
252 } else {
Douglas Gregor7bb87fc2009-11-11 16:39:34 +0000253 TPA.Revert();
Chris Lattner77cf72a2009-06-26 03:47:46 +0000254 break;
255 }
Mike Stump1eb44332009-09-09 15:08:12 +0000256
Douglas Gregor7bb87fc2009-11-11 16:39:34 +0000257 // 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();
Douglas Gregord6ab2322010-06-16 23:00:59 +0000267 TemplateTy Template;
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000268 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))
Douglas Gregord6ab2322010-06-16 23:00:59 +0000275 return true;
276 } else
John McCall9ba61662010-02-26 08:45:28 +0000277 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000278
Chris Lattner77cf72a2009-06-26 03:47:46 +0000279 continue;
280 }
Mike Stump1eb44332009-09-09 15:08:12 +0000281
Douglas Gregor39a8de12009-02-25 19:37:18 +0000282 if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000283 // We have
Douglas Gregor39a8de12009-02-25 19:37:18 +0000284 //
285 // simple-template-id '::'
286 //
287 // So we need to check whether the simple-template-id is of the
Douglas Gregorc45c2322009-03-31 00:43:58 +0000288 // right kind (it should name a type or be dependent), and then
289 // convert it into a type within the nested-name-specifier.
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +0000290 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregord4dca082010-02-24 18:44:31 +0000291 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
292 *MayBePseudoDestructor = true;
John McCall9ba61662010-02-26 08:45:28 +0000293 return false;
Douglas Gregord4dca082010-02-24 18:44:31 +0000294 }
295
Douglas Gregor6cd9d4a2011-03-04 21:37:14 +0000296 // Consume the template-id token.
297 ConsumeToken();
298
299 assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
300 SourceLocation CCLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000301
David Blaikie6796fc12011-11-07 03:30:03 +0000302 HasScopeSpecifier = true;
Douglas Gregor6cd9d4a2011-03-04 21:37:14 +0000303
304 ASTTemplateArgsPtr TemplateArgsPtr(Actions,
305 TemplateId->getTemplateArgs(),
306 TemplateId->NumArgs);
307
308 if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000309 SS,
310 TemplateId->TemplateKWLoc,
Douglas Gregor6cd9d4a2011-03-04 21:37:14 +0000311 TemplateId->Template,
312 TemplateId->TemplateNameLoc,
313 TemplateId->LAngleLoc,
314 TemplateArgsPtr,
315 TemplateId->RAngleLoc,
316 CCLoc,
317 EnteringContext)) {
318 SourceLocation StartLoc
319 = SS.getBeginLoc().isValid()? SS.getBeginLoc()
320 : TemplateId->TemplateNameLoc;
321 SS.SetInvalid(SourceRange(StartLoc, CCLoc));
Chris Lattner67b9e832009-06-26 03:45:46 +0000322 }
Argyrios Kyrtzidiseccce7e2011-05-03 18:45:38 +0000323
Douglas Gregor6cd9d4a2011-03-04 21:37:14 +0000324 continue;
Douglas Gregor39a8de12009-02-25 19:37:18 +0000325 }
326
Chris Lattner5c7f7862009-06-26 03:52:38 +0000327
328 // The rest of the nested-name-specifier possibilities start with
329 // tok::identifier.
330 if (Tok.isNot(tok::identifier))
331 break;
332
333 IdentifierInfo &II = *Tok.getIdentifierInfo();
334
335 // nested-name-specifier:
336 // type-name '::'
337 // namespace-name '::'
338 // nested-name-specifier identifier '::'
339 Token Next = NextToken();
Chris Lattner46646492009-12-07 01:36:53 +0000340
341 // If we get foo:bar, this is almost certainly a typo for foo::bar. Recover
342 // and emit a fixit hint for it.
Douglas Gregorb10cd042010-02-21 18:36:56 +0000343 if (Next.is(tok::colon) && !ColonIsSacred) {
Douglas Gregor2e4c34a2011-02-24 00:17:56 +0000344 if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, II,
345 Tok.getLocation(),
346 Next.getLocation(), ObjectType,
Douglas Gregorb10cd042010-02-21 18:36:56 +0000347 EnteringContext) &&
348 // If the token after the colon isn't an identifier, it's still an
349 // error, but they probably meant something else strange so don't
350 // recover like this.
351 PP.LookAhead(1).is(tok::identifier)) {
352 Diag(Next, diag::err_unexected_colon_in_nested_name_spec)
Douglas Gregor849b2432010-03-31 17:46:05 +0000353 << FixItHint::CreateReplacement(Next.getLocation(), "::");
Douglas Gregorb10cd042010-02-21 18:36:56 +0000354
355 // Recover as if the user wrote '::'.
356 Next.setKind(tok::coloncolon);
357 }
Chris Lattner46646492009-12-07 01:36:53 +0000358 }
359
Chris Lattner5c7f7862009-06-26 03:52:38 +0000360 if (Next.is(tok::coloncolon)) {
Douglas Gregor77549082010-02-24 21:29:12 +0000361 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) &&
Douglas Gregor23c94db2010-07-02 17:43:08 +0000362 !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, Tok.getLocation(),
Douglas Gregor77549082010-02-24 21:29:12 +0000363 II, ObjectType)) {
Douglas Gregord4dca082010-02-24 18:44:31 +0000364 *MayBePseudoDestructor = true;
John McCall9ba61662010-02-26 08:45:28 +0000365 return false;
Douglas Gregord4dca082010-02-24 18:44:31 +0000366 }
367
Chris Lattner5c7f7862009-06-26 03:52:38 +0000368 // We have an identifier followed by a '::'. Lookup this name
369 // as the name in a nested-name-specifier.
370 SourceLocation IdLoc = ConsumeToken();
Chris Lattner46646492009-12-07 01:36:53 +0000371 assert((Tok.is(tok::coloncolon) || Tok.is(tok::colon)) &&
372 "NextToken() not working properly!");
Chris Lattner5c7f7862009-06-26 03:52:38 +0000373 SourceLocation CCLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000374
Douglas Gregor2e4c34a2011-02-24 00:17:56 +0000375 HasScopeSpecifier = true;
376 if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(), II, IdLoc, CCLoc,
377 ObjectType, EnteringContext, SS))
378 SS.SetInvalid(SourceRange(IdLoc, CCLoc));
379
Chris Lattner5c7f7862009-06-26 03:52:38 +0000380 continue;
381 }
Mike Stump1eb44332009-09-09 15:08:12 +0000382
Richard Trieu950be712011-09-19 19:01:00 +0000383 CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
Richard Smithea698b32011-04-14 21:45:45 +0000384
Chris Lattner5c7f7862009-06-26 03:52:38 +0000385 // nested-name-specifier:
386 // type-name '<'
387 if (Next.is(tok::less)) {
388 TemplateTy Template;
Douglas Gregor014e88d2009-11-03 23:16:33 +0000389 UnqualifiedId TemplateName;
390 TemplateName.setIdentifier(&II, Tok.getLocation());
Douglas Gregor1fd6d442010-05-21 23:18:07 +0000391 bool MemberOfUnknownSpecialization;
Douglas Gregor23c94db2010-07-02 17:43:08 +0000392 if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
Abramo Bagnara7c153532010-08-06 12:11:11 +0000393 /*hasTemplateKeyword=*/false,
Douglas Gregor014e88d2009-11-03 23:16:33 +0000394 TemplateName,
Douglas Gregor2dd078a2009-09-02 22:59:36 +0000395 ObjectType,
Douglas Gregor495c35d2009-08-25 22:51:20 +0000396 EnteringContext,
Douglas Gregor1fd6d442010-05-21 23:18:07 +0000397 Template,
398 MemberOfUnknownSpecialization)) {
David Blaikie6796fc12011-11-07 03:30:03 +0000399 // We have found a template name, so annotate this token
Chris Lattner5c7f7862009-06-26 03:52:38 +0000400 // with a template-id annotation. We do not permit the
401 // template-id to be translated into a type annotation,
402 // because some clients (e.g., the parsing of class template
403 // specializations) still want to see the original template-id
404 // token.
Douglas Gregorca1bdd72009-11-04 00:56:37 +0000405 ConsumeToken();
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000406 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
407 TemplateName, false))
John McCall9ba61662010-02-26 08:45:28 +0000408 return true;
Chris Lattner5c7f7862009-06-26 03:52:38 +0000409 continue;
Douglas Gregord5ab9b02010-05-21 23:43:39 +0000410 }
411
412 if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
Francois Pichet4147d302011-03-27 19:41:34 +0000413 (IsTypename || IsTemplateArgumentList(1))) {
Douglas Gregord5ab9b02010-05-21 23:43:39 +0000414 // We have something like t::getAs<T>, where getAs is a
415 // member of an unknown specialization. However, this will only
416 // parse correctly as a template, so suggest the keyword 'template'
417 // before 'getAs' and treat this as a dependent template name.
Francois Pichet4147d302011-03-27 19:41:34 +0000418 unsigned DiagID = diag::err_missing_dependent_template_keyword;
David Blaikie4e4d0842012-03-11 07:00:24 +0000419 if (getLangOpts().MicrosoftExt)
Francois Pichetcf320c62011-04-22 08:25:24 +0000420 DiagID = diag::warn_missing_dependent_template_keyword;
Francois Pichet4147d302011-03-27 19:41:34 +0000421
422 Diag(Tok.getLocation(), DiagID)
Douglas Gregord5ab9b02010-05-21 23:43:39 +0000423 << II.getName()
424 << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
425
Douglas Gregord6ab2322010-06-16 23:00:59 +0000426 if (TemplateNameKind TNK
Douglas Gregor23c94db2010-07-02 17:43:08 +0000427 = Actions.ActOnDependentTemplateName(getCurScope(),
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000428 SS, SourceLocation(),
Douglas Gregord6ab2322010-06-16 23:00:59 +0000429 TemplateName, ObjectType,
430 EnteringContext, Template)) {
431 // Consume the identifier.
432 ConsumeToken();
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000433 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
434 TemplateName, false))
435 return true;
Douglas Gregord6ab2322010-06-16 23:00:59 +0000436 }
437 else
Douglas Gregord5ab9b02010-05-21 23:43:39 +0000438 return true;
Douglas Gregord6ab2322010-06-16 23:00:59 +0000439
Douglas Gregord5ab9b02010-05-21 23:43:39 +0000440 continue;
Chris Lattner5c7f7862009-06-26 03:52:38 +0000441 }
442 }
443
Douglas Gregor39a8de12009-02-25 19:37:18 +0000444 // We don't have any tokens that form the beginning of a
445 // nested-name-specifier, so we're done.
446 break;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000447 }
Mike Stump1eb44332009-09-09 15:08:12 +0000448
Douglas Gregord4dca082010-02-24 18:44:31 +0000449 // Even if we didn't see any pieces of a nested-name-specifier, we
450 // still check whether there is a tilde in this position, which
451 // indicates a potential pseudo-destructor.
452 if (CheckForDestructor && Tok.is(tok::tilde))
453 *MayBePseudoDestructor = true;
454
John McCall9ba61662010-02-26 08:45:28 +0000455 return false;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000456}
457
458/// ParseCXXIdExpression - Handle id-expression.
459///
460/// id-expression:
461/// unqualified-id
462/// qualified-id
463///
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000464/// qualified-id:
465/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
466/// '::' identifier
467/// '::' operator-function-id
Douglas Gregoredce4dd2009-06-30 22:34:41 +0000468/// '::' template-id
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000469///
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000470/// NOTE: The standard specifies that, for qualified-id, the parser does not
471/// expect:
472///
473/// '::' conversion-function-id
474/// '::' '~' class-name
475///
476/// This may cause a slight inconsistency on diagnostics:
477///
478/// class C {};
479/// namespace A {}
480/// void f() {
481/// :: A :: ~ C(); // Some Sema error about using destructor with a
482/// // namespace.
483/// :: ~ C(); // Some Parser error like 'unexpected ~'.
484/// }
485///
486/// We simplify the parser a bit and make it work like:
487///
488/// qualified-id:
489/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
490/// '::' unqualified-id
491///
492/// That way Sema can handle and report similar errors for namespaces and the
493/// global scope.
494///
Sebastian Redlebc07d52009-02-03 20:19:35 +0000495/// The isAddressOfOperand parameter indicates that this id-expression is a
496/// direct operand of the address-of operator. This is, besides member contexts,
497/// the only place where a qualified-id naming a non-static class member may
498/// appear.
499///
John McCall60d7b3a2010-08-24 06:29:42 +0000500ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000501 // qualified-id:
502 // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
503 // '::' unqualified-id
504 //
505 CXXScopeSpec SS;
Douglas Gregorefaa93a2011-11-07 17:33:42 +0000506 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), /*EnteringContext=*/false);
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000507
508 SourceLocation TemplateKWLoc;
Douglas Gregor02a24ee2009-11-03 16:56:39 +0000509 UnqualifiedId Name;
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000510 if (ParseUnqualifiedId(SS,
511 /*EnteringContext=*/false,
512 /*AllowDestructorName=*/false,
513 /*AllowConstructorName=*/false,
John McCallb3d87482010-08-24 05:47:05 +0000514 /*ObjectType=*/ ParsedType(),
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000515 TemplateKWLoc,
Douglas Gregor02a24ee2009-11-03 16:56:39 +0000516 Name))
517 return ExprError();
John McCallb681b612009-11-22 02:49:43 +0000518
519 // This is only the direct operand of an & operator if it is not
520 // followed by a postfix-expression suffix.
John McCall9c72c602010-08-27 09:08:28 +0000521 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
522 isAddressOfOperand = false;
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000523
524 return Actions.ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Name,
525 Tok.is(tok::l_paren), isAddressOfOperand);
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000526}
527
Douglas Gregorae7902c2011-08-04 15:30:47 +0000528/// ParseLambdaExpression - Parse a C++0x lambda expression.
529///
530/// lambda-expression:
531/// lambda-introducer lambda-declarator[opt] compound-statement
532///
533/// lambda-introducer:
534/// '[' lambda-capture[opt] ']'
535///
536/// lambda-capture:
537/// capture-default
538/// capture-list
539/// capture-default ',' capture-list
540///
541/// capture-default:
542/// '&'
543/// '='
544///
545/// capture-list:
546/// capture
547/// capture-list ',' capture
548///
549/// capture:
550/// identifier
551/// '&' identifier
552/// 'this'
553///
554/// lambda-declarator:
555/// '(' parameter-declaration-clause ')' attribute-specifier[opt]
556/// 'mutable'[opt] exception-specification[opt]
557/// trailing-return-type[opt]
558///
559ExprResult Parser::ParseLambdaExpression() {
560 // Parse lambda-introducer.
561 LambdaIntroducer Intro;
562
563 llvm::Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro));
564 if (DiagID) {
565 Diag(Tok, DiagID.getValue());
566 SkipUntil(tok::r_square);
Eli Friedmandc3b7232012-01-04 02:40:39 +0000567 SkipUntil(tok::l_brace);
568 SkipUntil(tok::r_brace);
569 return ExprError();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000570 }
571
572 return ParseLambdaExpressionAfterIntroducer(Intro);
573}
574
575/// TryParseLambdaExpression - Use lookahead and potentially tentative
576/// parsing to determine if we are looking at a C++0x lambda expression, and parse
577/// it if we are.
578///
579/// If we are not looking at a lambda expression, returns ExprError().
580ExprResult Parser::TryParseLambdaExpression() {
David Blaikie4e4d0842012-03-11 07:00:24 +0000581 assert(getLangOpts().CPlusPlus0x
Douglas Gregorae7902c2011-08-04 15:30:47 +0000582 && Tok.is(tok::l_square)
583 && "Not at the start of a possible lambda expression.");
584
585 const Token Next = NextToken(), After = GetLookAheadToken(2);
586
587 // If lookahead indicates this is a lambda...
588 if (Next.is(tok::r_square) || // []
589 Next.is(tok::equal) || // [=
590 (Next.is(tok::amp) && // [&] or [&,
591 (After.is(tok::r_square) ||
592 After.is(tok::comma))) ||
593 (Next.is(tok::identifier) && // [identifier]
594 After.is(tok::r_square))) {
595 return ParseLambdaExpression();
596 }
597
Eli Friedmandc3b7232012-01-04 02:40:39 +0000598 // If lookahead indicates an ObjC message send...
599 // [identifier identifier
Douglas Gregorae7902c2011-08-04 15:30:47 +0000600 if (Next.is(tok::identifier) && After.is(tok::identifier)) {
Eli Friedmandc3b7232012-01-04 02:40:39 +0000601 return ExprEmpty();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000602 }
603
Eli Friedmandc3b7232012-01-04 02:40:39 +0000604 // Here, we're stuck: lambda introducers and Objective-C message sends are
605 // unambiguous, but it requires arbitrary lookhead. [a,b,c,d,e,f,g] is a
606 // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send. Instead of
607 // writing two routines to parse a lambda introducer, just try to parse
608 // a lambda introducer first, and fall back if that fails.
609 // (TryParseLambdaIntroducer never produces any diagnostic output.)
Douglas Gregorae7902c2011-08-04 15:30:47 +0000610 LambdaIntroducer Intro;
611 if (TryParseLambdaIntroducer(Intro))
Eli Friedmandc3b7232012-01-04 02:40:39 +0000612 return ExprEmpty();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000613 return ParseLambdaExpressionAfterIntroducer(Intro);
614}
615
616/// ParseLambdaExpression - Parse a lambda introducer.
617///
618/// Returns a DiagnosticID if it hit something unexpected.
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000619llvm::Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro){
Douglas Gregorae7902c2011-08-04 15:30:47 +0000620 typedef llvm::Optional<unsigned> DiagResult;
621
622 assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000623 BalancedDelimiterTracker T(*this, tok::l_square);
624 T.consumeOpen();
625
626 Intro.Range.setBegin(T.getOpenLocation());
Douglas Gregorae7902c2011-08-04 15:30:47 +0000627
628 bool first = true;
629
630 // Parse capture-default.
631 if (Tok.is(tok::amp) &&
632 (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
633 Intro.Default = LCD_ByRef;
Douglas Gregor3ac109c2012-02-10 17:46:20 +0000634 Intro.DefaultLoc = ConsumeToken();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000635 first = false;
636 } else if (Tok.is(tok::equal)) {
637 Intro.Default = LCD_ByCopy;
Douglas Gregor3ac109c2012-02-10 17:46:20 +0000638 Intro.DefaultLoc = ConsumeToken();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000639 first = false;
640 }
641
642 while (Tok.isNot(tok::r_square)) {
643 if (!first) {
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000644 if (Tok.isNot(tok::comma)) {
Douglas Gregor437fbc52012-07-31 00:50:07 +0000645 // Provide a completion for a lambda introducer here. Except
646 // in Objective-C, where this is Almost Surely meant to be a message
647 // send. In that case, fail here and let the ObjC message
648 // expression parser perform the completion.
Douglas Gregord48ab062012-07-31 15:27:48 +0000649 if (Tok.is(tok::code_completion) &&
650 !(getLangOpts().ObjC1 && Intro.Default == LCD_None &&
651 !Intro.Captures.empty())) {
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000652 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
653 /*AfterAmpersand=*/false);
654 ConsumeCodeCompletionToken();
655 break;
656 }
657
Douglas Gregorae7902c2011-08-04 15:30:47 +0000658 return DiagResult(diag::err_expected_comma_or_rsquare);
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000659 }
Douglas Gregorae7902c2011-08-04 15:30:47 +0000660 ConsumeToken();
661 }
662
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000663 if (Tok.is(tok::code_completion)) {
664 // If we're in Objective-C++ and we have a bare '[', then this is more
665 // likely to be a message receiver.
David Blaikie4e4d0842012-03-11 07:00:24 +0000666 if (getLangOpts().ObjC1 && first)
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000667 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
668 else
669 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
670 /*AfterAmpersand=*/false);
671 ConsumeCodeCompletionToken();
672 break;
673 }
Douglas Gregorae7902c2011-08-04 15:30:47 +0000674
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000675 first = false;
676
Douglas Gregorae7902c2011-08-04 15:30:47 +0000677 // Parse capture.
678 LambdaCaptureKind Kind = LCK_ByCopy;
679 SourceLocation Loc;
680 IdentifierInfo* Id = 0;
Douglas Gregora7365242012-02-14 19:27:52 +0000681 SourceLocation EllipsisLoc;
682
Douglas Gregorae7902c2011-08-04 15:30:47 +0000683 if (Tok.is(tok::kw_this)) {
684 Kind = LCK_This;
685 Loc = ConsumeToken();
686 } else {
687 if (Tok.is(tok::amp)) {
688 Kind = LCK_ByRef;
689 ConsumeToken();
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000690
691 if (Tok.is(tok::code_completion)) {
692 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
693 /*AfterAmpersand=*/true);
694 ConsumeCodeCompletionToken();
695 break;
696 }
Douglas Gregorae7902c2011-08-04 15:30:47 +0000697 }
698
699 if (Tok.is(tok::identifier)) {
700 Id = Tok.getIdentifierInfo();
701 Loc = ConsumeToken();
Douglas Gregora7365242012-02-14 19:27:52 +0000702
703 if (Tok.is(tok::ellipsis))
704 EllipsisLoc = ConsumeToken();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000705 } else if (Tok.is(tok::kw_this)) {
706 // FIXME: If we want to suggest a fixit here, will need to return more
707 // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be
708 // Clear()ed to prevent emission in case of tentative parsing?
709 return DiagResult(diag::err_this_captured_by_reference);
710 } else {
711 return DiagResult(diag::err_expected_capture);
712 }
713 }
714
Douglas Gregora7365242012-02-14 19:27:52 +0000715 Intro.addCapture(Kind, Loc, Id, EllipsisLoc);
Douglas Gregorae7902c2011-08-04 15:30:47 +0000716 }
717
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000718 T.consumeClose();
719 Intro.Range.setEnd(T.getCloseLocation());
Douglas Gregorae7902c2011-08-04 15:30:47 +0000720
721 return DiagResult();
722}
723
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000724/// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
Douglas Gregorae7902c2011-08-04 15:30:47 +0000725///
726/// Returns true if it hit something unexpected.
727bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
728 TentativeParsingAction PA(*this);
729
730 llvm::Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro));
731
732 if (DiagID) {
733 PA.Revert();
734 return true;
735 }
736
737 PA.Commit();
738 return false;
739}
740
741/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
742/// expression.
743ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
744 LambdaIntroducer &Intro) {
Eli Friedmandc3b7232012-01-04 02:40:39 +0000745 SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
746 Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
747
748 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
749 "lambda expression parsing");
750
Douglas Gregorae7902c2011-08-04 15:30:47 +0000751 // Parse lambda-declarator[opt].
752 DeclSpec DS(AttrFactory);
Eli Friedmanf88c4002012-01-04 04:41:38 +0000753 Declarator D(DS, Declarator::LambdaExprContext);
Douglas Gregorae7902c2011-08-04 15:30:47 +0000754
755 if (Tok.is(tok::l_paren)) {
756 ParseScope PrototypeScope(this,
757 Scope::FunctionPrototypeScope |
758 Scope::DeclScope);
759
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000760 SourceLocation DeclLoc, DeclEndLoc;
761 BalancedDelimiterTracker T(*this, tok::l_paren);
762 T.consumeOpen();
763 DeclLoc = T.getOpenLocation();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000764
765 // Parse parameter-declaration-clause.
766 ParsedAttributes Attr(AttrFactory);
767 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
768 SourceLocation EllipsisLoc;
769
770 if (Tok.isNot(tok::r_paren))
771 ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
772
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000773 T.consumeClose();
774 DeclEndLoc = T.getCloseLocation();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000775
776 // Parse 'mutable'[opt].
777 SourceLocation MutableLoc;
778 if (Tok.is(tok::kw_mutable)) {
779 MutableLoc = ConsumeToken();
780 DeclEndLoc = MutableLoc;
781 }
782
783 // Parse exception-specification[opt].
784 ExceptionSpecificationType ESpecType = EST_None;
785 SourceRange ESpecRange;
786 llvm::SmallVector<ParsedType, 2> DynamicExceptions;
787 llvm::SmallVector<SourceRange, 2> DynamicExceptionRanges;
788 ExprResult NoexceptExpr;
Richard Smitha058fd42012-05-02 22:22:32 +0000789 ESpecType = tryParseExceptionSpecification(ESpecRange,
Douglas Gregor74e2fc32012-04-16 18:27:27 +0000790 DynamicExceptions,
791 DynamicExceptionRanges,
Richard Smitha058fd42012-05-02 22:22:32 +0000792 NoexceptExpr);
Douglas Gregorae7902c2011-08-04 15:30:47 +0000793
794 if (ESpecType != EST_None)
795 DeclEndLoc = ESpecRange.getEnd();
796
797 // Parse attribute-specifier[opt].
798 MaybeParseCXX0XAttributes(Attr, &DeclEndLoc);
799
800 // Parse trailing-return-type[opt].
Richard Smith54655be2012-06-12 01:51:59 +0000801 TypeResult TrailingReturnType;
Douglas Gregorae7902c2011-08-04 15:30:47 +0000802 if (Tok.is(tok::arrow)) {
803 SourceRange Range;
Richard Smith54655be2012-06-12 01:51:59 +0000804 TrailingReturnType = ParseTrailingReturnType(Range);
Douglas Gregorae7902c2011-08-04 15:30:47 +0000805 if (Range.getEnd().isValid())
806 DeclEndLoc = Range.getEnd();
807 }
808
809 PrototypeScope.Exit();
810
811 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
812 /*isVariadic=*/EllipsisLoc.isValid(),
Richard Smithb9c62612012-07-30 21:30:52 +0000813 /*isAmbiguous=*/false, EllipsisLoc,
Douglas Gregorae7902c2011-08-04 15:30:47 +0000814 ParamInfo.data(), ParamInfo.size(),
815 DS.getTypeQualifiers(),
816 /*RefQualifierIsLValueRef=*/true,
817 /*RefQualifierLoc=*/SourceLocation(),
Douglas Gregor43f51032011-10-19 06:04:55 +0000818 /*ConstQualifierLoc=*/SourceLocation(),
819 /*VolatileQualifierLoc=*/SourceLocation(),
Douglas Gregorae7902c2011-08-04 15:30:47 +0000820 MutableLoc,
821 ESpecType, ESpecRange.getBegin(),
822 DynamicExceptions.data(),
823 DynamicExceptionRanges.data(),
824 DynamicExceptions.size(),
825 NoexceptExpr.isUsable() ?
826 NoexceptExpr.get() : 0,
827 DeclLoc, DeclEndLoc, D,
828 TrailingReturnType),
829 Attr, DeclEndLoc);
Douglas Gregorc9ecec42012-02-16 21:53:36 +0000830 } else if (Tok.is(tok::kw_mutable) || Tok.is(tok::arrow)) {
831 // It's common to forget that one needs '()' before 'mutable' or the
832 // result type. Deal with this.
833 Diag(Tok, diag::err_lambda_missing_parens)
834 << Tok.is(tok::arrow)
835 << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
836 SourceLocation DeclLoc = Tok.getLocation();
837 SourceLocation DeclEndLoc = DeclLoc;
838
839 // Parse 'mutable', if it's there.
840 SourceLocation MutableLoc;
841 if (Tok.is(tok::kw_mutable)) {
842 MutableLoc = ConsumeToken();
843 DeclEndLoc = MutableLoc;
844 }
845
846 // Parse the return type, if there is one.
Richard Smith54655be2012-06-12 01:51:59 +0000847 TypeResult TrailingReturnType;
Douglas Gregorc9ecec42012-02-16 21:53:36 +0000848 if (Tok.is(tok::arrow)) {
849 SourceRange Range;
Richard Smith54655be2012-06-12 01:51:59 +0000850 TrailingReturnType = ParseTrailingReturnType(Range);
Douglas Gregorc9ecec42012-02-16 21:53:36 +0000851 if (Range.getEnd().isValid())
852 DeclEndLoc = Range.getEnd();
853 }
854
855 ParsedAttributes Attr(AttrFactory);
856 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
857 /*isVariadic=*/false,
Richard Smithb9c62612012-07-30 21:30:52 +0000858 /*isAmbiguous=*/false,
Douglas Gregorc9ecec42012-02-16 21:53:36 +0000859 /*EllipsisLoc=*/SourceLocation(),
860 /*Params=*/0, /*NumParams=*/0,
861 /*TypeQuals=*/0,
862 /*RefQualifierIsLValueRef=*/true,
863 /*RefQualifierLoc=*/SourceLocation(),
864 /*ConstQualifierLoc=*/SourceLocation(),
865 /*VolatileQualifierLoc=*/SourceLocation(),
866 MutableLoc,
867 EST_None,
868 /*ESpecLoc=*/SourceLocation(),
869 /*Exceptions=*/0,
870 /*ExceptionRanges=*/0,
871 /*NumExceptions=*/0,
872 /*NoexceptExpr=*/0,
873 DeclLoc, DeclEndLoc, D,
874 TrailingReturnType),
875 Attr, DeclEndLoc);
Douglas Gregorae7902c2011-08-04 15:30:47 +0000876 }
Douglas Gregorc9ecec42012-02-16 21:53:36 +0000877
Douglas Gregorae7902c2011-08-04 15:30:47 +0000878
Eli Friedman906a7e12012-01-06 03:05:34 +0000879 // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
880 // it.
Douglas Gregorfccfb622012-02-21 22:51:27 +0000881 unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope;
Douglas Gregorfccfb622012-02-21 22:51:27 +0000882 ParseScope BodyScope(this, ScopeFlags);
Eli Friedman906a7e12012-01-06 03:05:34 +0000883
Eli Friedmanec9ea722012-01-05 03:35:19 +0000884 Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
885
Douglas Gregorae7902c2011-08-04 15:30:47 +0000886 // Parse compound-statement.
Eli Friedmandc3b7232012-01-04 02:40:39 +0000887 if (!Tok.is(tok::l_brace)) {
Douglas Gregorae7902c2011-08-04 15:30:47 +0000888 Diag(Tok, diag::err_expected_lambda_body);
Eli Friedmandc3b7232012-01-04 02:40:39 +0000889 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
890 return ExprError();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000891 }
892
Eli Friedmandc3b7232012-01-04 02:40:39 +0000893 StmtResult Stmt(ParseCompoundStatementBody());
894 BodyScope.Exit();
895
Eli Friedmandeeab902012-01-04 02:46:53 +0000896 if (!Stmt.isInvalid())
Douglas Gregor9e8c92a2012-02-20 19:44:39 +0000897 return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.take(), getCurScope());
Eli Friedmandc3b7232012-01-04 02:40:39 +0000898
Eli Friedmandeeab902012-01-04 02:46:53 +0000899 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
900 return ExprError();
Douglas Gregorae7902c2011-08-04 15:30:47 +0000901}
902
Reid Spencer5f016e22007-07-11 17:01:13 +0000903/// ParseCXXCasts - This handles the various ways to cast expressions to another
904/// type.
905///
906/// postfix-expression: [C++ 5.2p1]
907/// 'dynamic_cast' '<' type-name '>' '(' expression ')'
908/// 'static_cast' '<' type-name '>' '(' expression ')'
909/// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
910/// 'const_cast' '<' type-name '>' '(' expression ')'
911///
John McCall60d7b3a2010-08-24 06:29:42 +0000912ExprResult Parser::ParseCXXCasts() {
Reid Spencer5f016e22007-07-11 17:01:13 +0000913 tok::TokenKind Kind = Tok.getKind();
914 const char *CastName = 0; // For error messages
915
916 switch (Kind) {
David Blaikieeb2d1f12011-09-23 20:26:49 +0000917 default: llvm_unreachable("Unknown C++ cast!");
Reid Spencer5f016e22007-07-11 17:01:13 +0000918 case tok::kw_const_cast: CastName = "const_cast"; break;
919 case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
920 case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
921 case tok::kw_static_cast: CastName = "static_cast"; break;
922 }
923
924 SourceLocation OpLoc = ConsumeToken();
925 SourceLocation LAngleBracketLoc = Tok.getLocation();
926
Richard Smithea698b32011-04-14 21:45:45 +0000927 // Check for "<::" which is parsed as "[:". If found, fix token stream,
928 // diagnose error, suggest fix, and recover parsing.
Richard Smith78fe3e02012-08-20 17:37:52 +0000929 if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
930 Token Next = NextToken();
931 if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
932 FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
933 }
Richard Smithea698b32011-04-14 21:45:45 +0000934
Reid Spencer5f016e22007-07-11 17:01:13 +0000935 if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
Sebastian Redl20df9b72008-12-11 22:51:44 +0000936 return ExprError();
Reid Spencer5f016e22007-07-11 17:01:13 +0000937
Argyrios Kyrtzidis31862ba2011-07-01 22:22:50 +0000938 // Parse the common declaration-specifiers piece.
939 DeclSpec DS(AttrFactory);
940 ParseSpecifierQualifierList(DS);
941
942 // Parse the abstract-declarator, if present.
943 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
944 ParseDeclarator(DeclaratorInfo);
945
Reid Spencer5f016e22007-07-11 17:01:13 +0000946 SourceLocation RAngleBracketLoc = Tok.getLocation();
947
Chris Lattner1ab3b962008-11-18 07:48:38 +0000948 if (ExpectAndConsume(tok::greater, diag::err_expected_greater))
Sebastian Redl20df9b72008-12-11 22:51:44 +0000949 return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << "<");
Reid Spencer5f016e22007-07-11 17:01:13 +0000950
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000951 SourceLocation LParenLoc, RParenLoc;
952 BalancedDelimiterTracker T(*this, tok::l_paren);
Reid Spencer5f016e22007-07-11 17:01:13 +0000953
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000954 if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
Argyrios Kyrtzidis21e7ad22009-05-22 10:23:16 +0000955 return ExprError();
Reid Spencer5f016e22007-07-11 17:01:13 +0000956
John McCall60d7b3a2010-08-24 06:29:42 +0000957 ExprResult Result = ParseExpression();
Mike Stump1eb44332009-09-09 15:08:12 +0000958
Argyrios Kyrtzidis21e7ad22009-05-22 10:23:16 +0000959 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000960 T.consumeClose();
Reid Spencer5f016e22007-07-11 17:01:13 +0000961
Argyrios Kyrtzidis31862ba2011-07-01 22:22:50 +0000962 if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
Douglas Gregor49badde2008-10-27 19:41:14 +0000963 Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
Argyrios Kyrtzidis31862ba2011-07-01 22:22:50 +0000964 LAngleBracketLoc, DeclaratorInfo,
Douglas Gregor809070a2009-02-18 17:45:20 +0000965 RAngleBracketLoc,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000966 T.getOpenLocation(), Result.take(),
967 T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +0000968
Benjamin Kramer3fe198b2012-08-23 21:35:17 +0000969 return Result;
Reid Spencer5f016e22007-07-11 17:01:13 +0000970}
971
Sebastian Redlc42e1182008-11-11 11:37:55 +0000972/// ParseCXXTypeid - This handles the C++ typeid expression.
973///
974/// postfix-expression: [C++ 5.2p1]
975/// 'typeid' '(' expression ')'
976/// 'typeid' '(' type-id ')'
977///
John McCall60d7b3a2010-08-24 06:29:42 +0000978ExprResult Parser::ParseCXXTypeid() {
Sebastian Redlc42e1182008-11-11 11:37:55 +0000979 assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
980
981 SourceLocation OpLoc = ConsumeToken();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000982 SourceLocation LParenLoc, RParenLoc;
983 BalancedDelimiterTracker T(*this, tok::l_paren);
Sebastian Redlc42e1182008-11-11 11:37:55 +0000984
985 // typeid expressions are always parenthesized.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000986 if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
Sebastian Redl20df9b72008-12-11 22:51:44 +0000987 return ExprError();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000988 LParenLoc = T.getOpenLocation();
Sebastian Redlc42e1182008-11-11 11:37:55 +0000989
John McCall60d7b3a2010-08-24 06:29:42 +0000990 ExprResult Result;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000991
Richard Smith05766812012-08-18 00:55:03 +0000992 // C++0x [expr.typeid]p3:
993 // When typeid is applied to an expression other than an lvalue of a
994 // polymorphic class type [...] The expression is an unevaluated
995 // operand (Clause 5).
996 //
997 // Note that we can't tell whether the expression is an lvalue of a
998 // polymorphic class type until after we've parsed the expression; we
999 // speculatively assume the subexpression is unevaluated, and fix it up
1000 // later.
1001 //
1002 // We enter the unevaluated context before trying to determine whether we
1003 // have a type-id, because the tentative parse logic will try to resolve
1004 // names, and must treat them as unevaluated.
1005 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
1006
Sebastian Redlc42e1182008-11-11 11:37:55 +00001007 if (isTypeIdInParens()) {
Douglas Gregor809070a2009-02-18 17:45:20 +00001008 TypeResult Ty = ParseTypeName();
Sebastian Redlc42e1182008-11-11 11:37:55 +00001009
1010 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001011 T.consumeClose();
1012 RParenLoc = T.getCloseLocation();
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +00001013 if (Ty.isInvalid() || RParenLoc.isInvalid())
Sebastian Redl20df9b72008-12-11 22:51:44 +00001014 return ExprError();
Sebastian Redlc42e1182008-11-11 11:37:55 +00001015
1016 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
John McCallb3d87482010-08-24 05:47:05 +00001017 Ty.get().getAsOpaquePtr(), RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001018 } else {
1019 Result = ParseExpression();
1020
1021 // Match the ')'.
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00001022 if (Result.isInvalid())
Sebastian Redlc42e1182008-11-11 11:37:55 +00001023 SkipUntil(tok::r_paren);
1024 else {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001025 T.consumeClose();
1026 RParenLoc = T.getCloseLocation();
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +00001027 if (RParenLoc.isInvalid())
1028 return ExprError();
Douglas Gregorfadb53b2011-03-12 01:48:56 +00001029
Sebastian Redlc42e1182008-11-11 11:37:55 +00001030 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
Sebastian Redleffa8d12008-12-10 00:02:53 +00001031 Result.release(), RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001032 }
1033 }
1034
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001035 return Result;
Sebastian Redlc42e1182008-11-11 11:37:55 +00001036}
1037
Francois Pichet01b7c302010-09-08 12:20:18 +00001038/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1039///
1040/// '__uuidof' '(' expression ')'
1041/// '__uuidof' '(' type-id ')'
1042///
1043ExprResult Parser::ParseCXXUuidof() {
1044 assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1045
1046 SourceLocation OpLoc = ConsumeToken();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001047 BalancedDelimiterTracker T(*this, tok::l_paren);
Francois Pichet01b7c302010-09-08 12:20:18 +00001048
1049 // __uuidof expressions are always parenthesized.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001050 if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
Francois Pichet01b7c302010-09-08 12:20:18 +00001051 return ExprError();
1052
1053 ExprResult Result;
1054
1055 if (isTypeIdInParens()) {
1056 TypeResult Ty = ParseTypeName();
1057
1058 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001059 T.consumeClose();
Francois Pichet01b7c302010-09-08 12:20:18 +00001060
1061 if (Ty.isInvalid())
1062 return ExprError();
1063
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001064 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1065 Ty.get().getAsOpaquePtr(),
1066 T.getCloseLocation());
Francois Pichet01b7c302010-09-08 12:20:18 +00001067 } else {
1068 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
1069 Result = ParseExpression();
1070
1071 // Match the ')'.
1072 if (Result.isInvalid())
1073 SkipUntil(tok::r_paren);
1074 else {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001075 T.consumeClose();
Francois Pichet01b7c302010-09-08 12:20:18 +00001076
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001077 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1078 /*isType=*/false,
1079 Result.release(), T.getCloseLocation());
Francois Pichet01b7c302010-09-08 12:20:18 +00001080 }
1081 }
1082
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001083 return Result;
Francois Pichet01b7c302010-09-08 12:20:18 +00001084}
1085
Douglas Gregord4dca082010-02-24 18:44:31 +00001086/// \brief Parse a C++ pseudo-destructor expression after the base,
1087/// . or -> operator, and nested-name-specifier have already been
1088/// parsed.
1089///
1090/// postfix-expression: [C++ 5.2]
1091/// postfix-expression . pseudo-destructor-name
1092/// postfix-expression -> pseudo-destructor-name
1093///
1094/// pseudo-destructor-name:
1095/// ::[opt] nested-name-specifier[opt] type-name :: ~type-name
1096/// ::[opt] nested-name-specifier template simple-template-id ::
1097/// ~type-name
1098/// ::[opt] nested-name-specifier[opt] ~type-name
1099///
John McCall60d7b3a2010-08-24 06:29:42 +00001100ExprResult
Douglas Gregord4dca082010-02-24 18:44:31 +00001101Parser::ParseCXXPseudoDestructor(ExprArg Base, SourceLocation OpLoc,
1102 tok::TokenKind OpKind,
1103 CXXScopeSpec &SS,
John McCallb3d87482010-08-24 05:47:05 +00001104 ParsedType ObjectType) {
Douglas Gregord4dca082010-02-24 18:44:31 +00001105 // We're parsing either a pseudo-destructor-name or a dependent
1106 // member access that has the same form as a
1107 // pseudo-destructor-name. We parse both in the same way and let
1108 // the action model sort them out.
1109 //
1110 // Note that the ::[opt] nested-name-specifier[opt] has already
1111 // been parsed, and if there was a simple-template-id, it has
1112 // been coalesced into a template-id annotation token.
1113 UnqualifiedId FirstTypeName;
1114 SourceLocation CCLoc;
1115 if (Tok.is(tok::identifier)) {
1116 FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1117 ConsumeToken();
1118 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1119 CCLoc = ConsumeToken();
1120 } else if (Tok.is(tok::annot_template_id)) {
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001121 // FIXME: retrieve TemplateKWLoc from template-id annotation and
1122 // store it in the pseudo-dtor node (to be used when instantiating it).
Douglas Gregord4dca082010-02-24 18:44:31 +00001123 FirstTypeName.setTemplateId(
1124 (TemplateIdAnnotation *)Tok.getAnnotationValue());
1125 ConsumeToken();
1126 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1127 CCLoc = ConsumeToken();
1128 } else {
1129 FirstTypeName.setIdentifier(0, SourceLocation());
1130 }
1131
1132 // Parse the tilde.
1133 assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1134 SourceLocation TildeLoc = ConsumeToken();
David Blaikie91ec7892011-12-16 16:03:09 +00001135
1136 if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
1137 DeclSpec DS(AttrFactory);
Benjamin Kramer85c60db2011-12-18 12:18:02 +00001138 ParseDecltypeSpecifier(DS);
David Blaikie91ec7892011-12-16 16:03:09 +00001139 if (DS.getTypeSpecType() == TST_error)
1140 return ExprError();
1141 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc,
1142 OpKind, TildeLoc, DS,
1143 Tok.is(tok::l_paren));
1144 }
1145
Douglas Gregord4dca082010-02-24 18:44:31 +00001146 if (!Tok.is(tok::identifier)) {
1147 Diag(Tok, diag::err_destructor_tilde_identifier);
1148 return ExprError();
1149 }
1150
1151 // Parse the second type.
1152 UnqualifiedId SecondTypeName;
1153 IdentifierInfo *Name = Tok.getIdentifierInfo();
1154 SourceLocation NameLoc = ConsumeToken();
1155 SecondTypeName.setIdentifier(Name, NameLoc);
1156
1157 // If there is a '<', the second type name is a template-id. Parse
1158 // it as such.
1159 if (Tok.is(tok::less) &&
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001160 ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
1161 Name, NameLoc,
1162 false, ObjectType, SecondTypeName,
1163 /*AssumeTemplateName=*/true))
Douglas Gregord4dca082010-02-24 18:44:31 +00001164 return ExprError();
1165
John McCall9ae2f072010-08-23 23:25:46 +00001166 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base,
1167 OpLoc, OpKind,
Douglas Gregord4dca082010-02-24 18:44:31 +00001168 SS, FirstTypeName, CCLoc,
1169 TildeLoc, SecondTypeName,
1170 Tok.is(tok::l_paren));
1171}
1172
Reid Spencer5f016e22007-07-11 17:01:13 +00001173/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1174///
1175/// boolean-literal: [C++ 2.13.5]
1176/// 'true'
1177/// 'false'
John McCall60d7b3a2010-08-24 06:29:42 +00001178ExprResult Parser::ParseCXXBoolLiteral() {
Reid Spencer5f016e22007-07-11 17:01:13 +00001179 tok::TokenKind Kind = Tok.getKind();
Sebastian Redlf53597f2009-03-15 17:47:39 +00001180 return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
Reid Spencer5f016e22007-07-11 17:01:13 +00001181}
Chris Lattner50dd2892008-02-26 00:51:44 +00001182
1183/// ParseThrowExpression - This handles the C++ throw expression.
1184///
1185/// throw-expression: [C++ 15]
1186/// 'throw' assignment-expression[opt]
John McCall60d7b3a2010-08-24 06:29:42 +00001187ExprResult Parser::ParseThrowExpression() {
Chris Lattner50dd2892008-02-26 00:51:44 +00001188 assert(Tok.is(tok::kw_throw) && "Not throw!");
Chris Lattner50dd2892008-02-26 00:51:44 +00001189 SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
Sebastian Redl20df9b72008-12-11 22:51:44 +00001190
Chris Lattner2a2819a2008-04-06 06:02:23 +00001191 // If the current token isn't the start of an assignment-expression,
1192 // then the expression is not present. This handles things like:
1193 // "C ? throw : (void)42", which is crazy but legal.
1194 switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
1195 case tok::semi:
1196 case tok::r_paren:
1197 case tok::r_square:
1198 case tok::r_brace:
1199 case tok::colon:
1200 case tok::comma:
Douglas Gregorbca01b42011-07-06 22:04:06 +00001201 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, 0);
Chris Lattner50dd2892008-02-26 00:51:44 +00001202
Chris Lattner2a2819a2008-04-06 06:02:23 +00001203 default:
John McCall60d7b3a2010-08-24 06:29:42 +00001204 ExprResult Expr(ParseAssignmentExpression());
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001205 if (Expr.isInvalid()) return Expr;
Douglas Gregorbca01b42011-07-06 22:04:06 +00001206 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.take());
Chris Lattner2a2819a2008-04-06 06:02:23 +00001207 }
Chris Lattner50dd2892008-02-26 00:51:44 +00001208}
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +00001209
1210/// ParseCXXThis - This handles the C++ 'this' pointer.
1211///
1212/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1213/// a non-lvalue expression whose value is the address of the object for which
1214/// the function is called.
John McCall60d7b3a2010-08-24 06:29:42 +00001215ExprResult Parser::ParseCXXThis() {
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +00001216 assert(Tok.is(tok::kw_this) && "Not 'this'!");
1217 SourceLocation ThisLoc = ConsumeToken();
Sebastian Redlf53597f2009-03-15 17:47:39 +00001218 return Actions.ActOnCXXThis(ThisLoc);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +00001219}
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001220
1221/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1222/// Can be interpreted either as function-style casting ("int(x)")
1223/// or class type construction ("ClassType(x,y,z)")
1224/// or creation of a value-initialized type ("int()").
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001225/// See [C++ 5.2.3].
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001226///
1227/// postfix-expression: [C++ 5.2p1]
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001228/// simple-type-specifier '(' expression-list[opt] ')'
1229/// [C++0x] simple-type-specifier braced-init-list
1230/// typename-specifier '(' expression-list[opt] ')'
1231/// [C++0x] typename-specifier braced-init-list
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001232///
John McCall60d7b3a2010-08-24 06:29:42 +00001233ExprResult
Sebastian Redl20df9b72008-12-11 22:51:44 +00001234Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001235 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
John McCallb3d87482010-08-24 05:47:05 +00001236 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001237
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001238 assert((Tok.is(tok::l_paren) ||
David Blaikie4e4d0842012-03-11 07:00:24 +00001239 (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)))
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001240 && "Expected '(' or '{'!");
Douglas Gregorbc61bd82011-01-11 00:33:19 +00001241
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001242 if (Tok.is(tok::l_brace)) {
Sebastian Redl6dc00f62012-02-12 18:41:05 +00001243 ExprResult Init = ParseBraceInitializer();
1244 if (Init.isInvalid())
1245 return Init;
1246 Expr *InitList = Init.take();
1247 return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(),
1248 MultiExprArg(&InitList, 1),
1249 SourceLocation());
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001250 } else {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001251 BalancedDelimiterTracker T(*this, tok::l_paren);
1252 T.consumeOpen();
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001253
1254 ExprVector Exprs(Actions);
1255 CommaLocsTy CommaLocs;
1256
1257 if (Tok.isNot(tok::r_paren)) {
1258 if (ParseExpressionList(Exprs, CommaLocs)) {
1259 SkipUntil(tok::r_paren);
1260 return ExprError();
1261 }
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001262 }
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001263
1264 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001265 T.consumeClose();
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001266
1267 // TypeRep could be null, if it references an invalid typedef.
1268 if (!TypeRep)
1269 return ExprError();
1270
1271 assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1272 "Unexpected number of commas!");
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001273 return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001274 Exprs,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001275 T.getCloseLocation());
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001276 }
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001277}
1278
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001279/// ParseCXXCondition - if/switch/while condition expression.
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001280///
1281/// condition:
1282/// expression
1283/// type-specifier-seq declarator '=' assignment-expression
Richard Smith0635aa72012-02-22 06:49:09 +00001284/// [C++11] type-specifier-seq declarator '=' initializer-clause
1285/// [C++11] type-specifier-seq declarator braced-init-list
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001286/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1287/// '=' assignment-expression
1288///
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001289/// \param ExprResult if the condition was parsed as an expression, the
1290/// parsed expression.
1291///
1292/// \param DeclResult if the condition was parsed as a declaration, the
1293/// parsed declaration.
1294///
Douglas Gregor586596f2010-05-06 17:25:47 +00001295/// \param Loc The location of the start of the statement that requires this
1296/// condition, e.g., the "for" in a for loop.
1297///
1298/// \param ConvertToBoolean Whether the condition expression should be
1299/// converted to a boolean value.
1300///
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001301/// \returns true if there was a parsing, false otherwise.
John McCall60d7b3a2010-08-24 06:29:42 +00001302bool Parser::ParseCXXCondition(ExprResult &ExprOut,
1303 Decl *&DeclOut,
Douglas Gregor586596f2010-05-06 17:25:47 +00001304 SourceLocation Loc,
1305 bool ConvertToBoolean) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001306 if (Tok.is(tok::code_completion)) {
John McCallf312b1e2010-08-26 23:41:50 +00001307 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00001308 cutOffParsing();
1309 return true;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001310 }
1311
Sean Hunt2edf0a22012-06-23 05:07:58 +00001312 ParsedAttributesWithRange attrs(AttrFactory);
1313 MaybeParseCXX0XAttributes(attrs);
1314
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001315 if (!isCXXConditionDeclaration()) {
Sean Hunt2edf0a22012-06-23 05:07:58 +00001316 ProhibitAttributes(attrs);
1317
Douglas Gregor586596f2010-05-06 17:25:47 +00001318 // Parse the expression.
John McCall60d7b3a2010-08-24 06:29:42 +00001319 ExprOut = ParseExpression(); // expression
1320 DeclOut = 0;
1321 if (ExprOut.isInvalid())
Douglas Gregor586596f2010-05-06 17:25:47 +00001322 return true;
1323
1324 // If required, convert to a boolean value.
1325 if (ConvertToBoolean)
John McCall60d7b3a2010-08-24 06:29:42 +00001326 ExprOut
1327 = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprOut.get());
1328 return ExprOut.isInvalid();
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001329 }
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001330
1331 // type-specifier-seq
John McCall0b7e6782011-03-24 11:26:52 +00001332 DeclSpec DS(AttrFactory);
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001333 ParseSpecifierQualifierList(DS);
1334
1335 // declarator
1336 Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
1337 ParseDeclarator(DeclaratorInfo);
1338
1339 // simple-asm-expr[opt]
1340 if (Tok.is(tok::kw_asm)) {
Sebastian Redlab197ba2009-02-09 18:23:29 +00001341 SourceLocation Loc;
John McCall60d7b3a2010-08-24 06:29:42 +00001342 ExprResult AsmLabel(ParseSimpleAsm(&Loc));
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00001343 if (AsmLabel.isInvalid()) {
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001344 SkipUntil(tok::semi);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001345 return true;
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001346 }
Sebastian Redleffa8d12008-12-10 00:02:53 +00001347 DeclaratorInfo.setAsmLabel(AsmLabel.release());
Sebastian Redlab197ba2009-02-09 18:23:29 +00001348 DeclaratorInfo.SetRangeEnd(Loc);
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001349 }
1350
1351 // If attributes are present, parse them.
John McCall7f040a92010-12-24 02:08:15 +00001352 MaybeParseGNUAttributes(DeclaratorInfo);
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001353
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001354 // Type-check the declaration itself.
John McCall60d7b3a2010-08-24 06:29:42 +00001355 DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
John McCall7f040a92010-12-24 02:08:15 +00001356 DeclaratorInfo);
John McCall60d7b3a2010-08-24 06:29:42 +00001357 DeclOut = Dcl.get();
1358 ExprOut = ExprError();
Argyrios Kyrtzidisa6eb5f82010-10-08 02:39:23 +00001359
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001360 // '=' assignment-expression
Richard Trieud6c7c672012-01-18 22:54:52 +00001361 // If a '==' or '+=' is found, suggest a fixit to '='.
Richard Smith0635aa72012-02-22 06:49:09 +00001362 bool CopyInitialization = isTokenEqualOrEqualTypo();
1363 if (CopyInitialization)
Jeffrey Yasskindec09842011-01-18 02:00:16 +00001364 ConsumeToken();
Richard Smith0635aa72012-02-22 06:49:09 +00001365
1366 ExprResult InitExpr = ExprError();
David Blaikie4e4d0842012-03-11 07:00:24 +00001367 if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)) {
Richard Smith0635aa72012-02-22 06:49:09 +00001368 Diag(Tok.getLocation(),
1369 diag::warn_cxx98_compat_generalized_initializer_lists);
1370 InitExpr = ParseBraceInitializer();
1371 } else if (CopyInitialization) {
1372 InitExpr = ParseAssignmentExpression();
1373 } else if (Tok.is(tok::l_paren)) {
1374 // This was probably an attempt to initialize the variable.
1375 SourceLocation LParen = ConsumeParen(), RParen = LParen;
1376 if (SkipUntil(tok::r_paren, true, /*DontConsume=*/true))
1377 RParen = ConsumeParen();
1378 Diag(DeclOut ? DeclOut->getLocation() : LParen,
1379 diag::err_expected_init_in_condition_lparen)
1380 << SourceRange(LParen, RParen);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001381 } else {
Richard Smith0635aa72012-02-22 06:49:09 +00001382 Diag(DeclOut ? DeclOut->getLocation() : Tok.getLocation(),
1383 diag::err_expected_init_in_condition);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001384 }
Richard Smith0635aa72012-02-22 06:49:09 +00001385
1386 if (!InitExpr.isInvalid())
1387 Actions.AddInitializerToDecl(DeclOut, InitExpr.take(), !CopyInitialization,
1388 DS.getTypeSpecType() == DeclSpec::TST_auto);
1389
Douglas Gregor586596f2010-05-06 17:25:47 +00001390 // FIXME: Build a reference to this declaration? Convert it to bool?
1391 // (This is currently handled by Sema).
Richard Smith483b9f32011-02-21 20:05:19 +00001392
1393 Actions.FinalizeDeclaration(DeclOut);
Douglas Gregor586596f2010-05-06 17:25:47 +00001394
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001395 return false;
Argyrios Kyrtzidis71b914b2008-09-09 20:38:47 +00001396}
1397
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001398/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1399/// This should only be called when the current token is known to be part of
1400/// simple-type-specifier.
1401///
1402/// simple-type-specifier:
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001403/// '::'[opt] nested-name-specifier[opt] type-name
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001404/// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1405/// char
1406/// wchar_t
1407/// bool
1408/// short
1409/// int
1410/// long
1411/// signed
1412/// unsigned
1413/// float
1414/// double
1415/// void
1416/// [GNU] typeof-specifier
1417/// [C++0x] auto [TODO]
1418///
1419/// type-name:
1420/// class-name
1421/// enum-name
1422/// typedef-name
1423///
1424void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
1425 DS.SetRangeStart(Tok.getLocation());
1426 const char *PrevSpec;
John McCallfec54012009-08-03 20:12:06 +00001427 unsigned DiagID;
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001428 SourceLocation Loc = Tok.getLocation();
Mike Stump1eb44332009-09-09 15:08:12 +00001429
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001430 switch (Tok.getKind()) {
Chris Lattner55a7cef2009-01-05 00:13:00 +00001431 case tok::identifier: // foo::bar
1432 case tok::coloncolon: // ::foo::bar
David Blaikieb219cfc2011-09-23 05:06:16 +00001433 llvm_unreachable("Annotation token should already be formed!");
Mike Stump1eb44332009-09-09 15:08:12 +00001434 default:
David Blaikieb219cfc2011-09-23 05:06:16 +00001435 llvm_unreachable("Not a simple-type-specifier token!");
Chris Lattner55a7cef2009-01-05 00:13:00 +00001436
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001437 // type-name
Chris Lattnerb31757b2009-01-06 05:06:21 +00001438 case tok::annot_typename: {
Douglas Gregor6952f1e2011-01-19 20:10:05 +00001439 if (getTypeAnnotation(Tok))
1440 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
1441 getTypeAnnotation(Tok));
1442 else
1443 DS.SetTypeSpecError();
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00001444
1445 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1446 ConsumeToken();
1447
1448 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1449 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1450 // Objective-C interface. If we don't have Objective-C or a '<', this is
1451 // just a normal reference to a typedef name.
David Blaikie4e4d0842012-03-11 07:00:24 +00001452 if (Tok.is(tok::less) && getLangOpts().ObjC1)
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00001453 ParseObjCProtocolQualifiers(DS);
1454
1455 DS.Finish(Diags, PP);
1456 return;
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001457 }
Mike Stump1eb44332009-09-09 15:08:12 +00001458
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001459 // builtin types
1460 case tok::kw_short:
John McCallfec54012009-08-03 20:12:06 +00001461 DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001462 break;
1463 case tok::kw_long:
John McCallfec54012009-08-03 20:12:06 +00001464 DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001465 break;
Francois Pichet338d7f72011-04-28 01:59:37 +00001466 case tok::kw___int64:
1467 DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID);
1468 break;
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001469 case tok::kw_signed:
John McCallfec54012009-08-03 20:12:06 +00001470 DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001471 break;
1472 case tok::kw_unsigned:
John McCallfec54012009-08-03 20:12:06 +00001473 DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001474 break;
1475 case tok::kw_void:
John McCallfec54012009-08-03 20:12:06 +00001476 DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001477 break;
1478 case tok::kw_char:
John McCallfec54012009-08-03 20:12:06 +00001479 DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001480 break;
1481 case tok::kw_int:
John McCallfec54012009-08-03 20:12:06 +00001482 DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001483 break;
Richard Smith5a5a9712012-04-04 06:24:32 +00001484 case tok::kw___int128:
1485 DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID);
1486 break;
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00001487 case tok::kw_half:
1488 DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID);
1489 break;
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001490 case tok::kw_float:
John McCallfec54012009-08-03 20:12:06 +00001491 DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001492 break;
1493 case tok::kw_double:
John McCallfec54012009-08-03 20:12:06 +00001494 DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001495 break;
1496 case tok::kw_wchar_t:
John McCallfec54012009-08-03 20:12:06 +00001497 DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001498 break;
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00001499 case tok::kw_char16_t:
John McCallfec54012009-08-03 20:12:06 +00001500 DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00001501 break;
1502 case tok::kw_char32_t:
John McCallfec54012009-08-03 20:12:06 +00001503 DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00001504 break;
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001505 case tok::kw_bool:
John McCallfec54012009-08-03 20:12:06 +00001506 DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001507 break;
David Blaikie5e089fe2012-01-24 05:47:35 +00001508 case tok::annot_decltype:
1509 case tok::kw_decltype:
1510 DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
1511 return DS.Finish(Diags, PP);
Mike Stump1eb44332009-09-09 15:08:12 +00001512
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001513 // GNU typeof support.
1514 case tok::kw_typeof:
1515 ParseTypeofSpecifier(DS);
Douglas Gregor9b3064b2009-04-01 22:41:11 +00001516 DS.Finish(Diags, PP);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001517 return;
1518 }
Chris Lattnerb31757b2009-01-06 05:06:21 +00001519 if (Tok.is(tok::annot_typename))
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001520 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1521 else
1522 DS.SetRangeEnd(Tok.getLocation());
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001523 ConsumeToken();
Douglas Gregor9b3064b2009-04-01 22:41:11 +00001524 DS.Finish(Diags, PP);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001525}
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001526
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001527/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1528/// [dcl.name]), which is a non-empty sequence of type-specifiers,
1529/// e.g., "const short int". Note that the DeclSpec is *not* finished
1530/// by parsing the type-specifier-seq, because these sequences are
1531/// typically followed by some form of declarator. Returns true and
1532/// emits diagnostics if this is not a type-specifier-seq, false
1533/// otherwise.
1534///
1535/// type-specifier-seq: [C++ 8.1]
1536/// type-specifier type-specifier-seq[opt]
1537///
1538bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
Richard Smith69730c12012-03-12 07:56:15 +00001539 ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
Douglas Gregor396a9f22010-02-24 23:13:13 +00001540 DS.Finish(Diags, PP);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001541 return false;
1542}
1543
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001544/// \brief Finish parsing a C++ unqualified-id that is a template-id of
1545/// some form.
1546///
1547/// This routine is invoked when a '<' is encountered after an identifier or
1548/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1549/// whether the unqualified-id is actually a template-id. This routine will
1550/// then parse the template arguments and form the appropriate template-id to
1551/// return to the caller.
1552///
1553/// \param SS the nested-name-specifier that precedes this template-id, if
1554/// we're actually parsing a qualified-id.
1555///
1556/// \param Name for constructor and destructor names, this is the actual
1557/// identifier that may be a template-name.
1558///
1559/// \param NameLoc the location of the class-name in a constructor or
1560/// destructor.
1561///
1562/// \param EnteringContext whether we're entering the scope of the
1563/// nested-name-specifier.
1564///
Douglas Gregor46df8cc2009-11-03 21:24:04 +00001565/// \param ObjectType if this unqualified-id occurs within a member access
1566/// expression, the type of the base object whose member is being accessed.
1567///
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001568/// \param Id as input, describes the template-name or operator-function-id
1569/// that precedes the '<'. If template arguments were parsed successfully,
1570/// will be updated with the template-id.
1571///
Douglas Gregord4dca082010-02-24 18:44:31 +00001572/// \param AssumeTemplateId When true, this routine will assume that the name
1573/// refers to a template without performing name lookup to verify.
1574///
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001575/// \returns true if a parse error occurred, false otherwise.
1576bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001577 SourceLocation TemplateKWLoc,
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001578 IdentifierInfo *Name,
1579 SourceLocation NameLoc,
1580 bool EnteringContext,
John McCallb3d87482010-08-24 05:47:05 +00001581 ParsedType ObjectType,
Douglas Gregord4dca082010-02-24 18:44:31 +00001582 UnqualifiedId &Id,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001583 bool AssumeTemplateId) {
Douglas Gregor0278e122010-05-05 05:58:24 +00001584 assert((AssumeTemplateId || Tok.is(tok::less)) &&
1585 "Expected '<' to finish parsing a template-id");
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001586
1587 TemplateTy Template;
1588 TemplateNameKind TNK = TNK_Non_template;
1589 switch (Id.getKind()) {
1590 case UnqualifiedId::IK_Identifier:
Douglas Gregor014e88d2009-11-03 23:16:33 +00001591 case UnqualifiedId::IK_OperatorFunctionId:
Sean Hunte6252d12009-11-28 08:58:14 +00001592 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregord4dca082010-02-24 18:44:31 +00001593 if (AssumeTemplateId) {
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001594 TNK = Actions.ActOnDependentTemplateName(getCurScope(), SS, TemplateKWLoc,
Douglas Gregord6ab2322010-06-16 23:00:59 +00001595 Id, ObjectType, EnteringContext,
1596 Template);
1597 if (TNK == TNK_Non_template)
1598 return true;
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001599 } else {
1600 bool MemberOfUnknownSpecialization;
Abramo Bagnara7c153532010-08-06 12:11:11 +00001601 TNK = Actions.isTemplateName(getCurScope(), SS,
1602 TemplateKWLoc.isValid(), Id,
1603 ObjectType, EnteringContext, Template,
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001604 MemberOfUnknownSpecialization);
1605
1606 if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
1607 ObjectType && IsTemplateArgumentList()) {
1608 // We have something like t->getAs<T>(), where getAs is a
1609 // member of an unknown specialization. However, this will only
1610 // parse correctly as a template, so suggest the keyword 'template'
1611 // before 'getAs' and treat this as a dependent template name.
1612 std::string Name;
1613 if (Id.getKind() == UnqualifiedId::IK_Identifier)
1614 Name = Id.Identifier->getName();
1615 else {
1616 Name = "operator ";
1617 if (Id.getKind() == UnqualifiedId::IK_OperatorFunctionId)
1618 Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
1619 else
1620 Name += Id.Identifier->getName();
1621 }
1622 Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
1623 << Name
1624 << FixItHint::CreateInsertion(Id.StartLocation, "template ");
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001625 TNK = Actions.ActOnDependentTemplateName(getCurScope(),
1626 SS, TemplateKWLoc, Id,
1627 ObjectType, EnteringContext,
1628 Template);
Douglas Gregord6ab2322010-06-16 23:00:59 +00001629 if (TNK == TNK_Non_template)
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001630 return true;
1631 }
1632 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001633 break;
1634
Douglas Gregor014e88d2009-11-03 23:16:33 +00001635 case UnqualifiedId::IK_ConstructorName: {
1636 UnqualifiedId TemplateName;
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001637 bool MemberOfUnknownSpecialization;
Douglas Gregor014e88d2009-11-03 23:16:33 +00001638 TemplateName.setIdentifier(Name, NameLoc);
Abramo Bagnara7c153532010-08-06 12:11:11 +00001639 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
1640 TemplateName, ObjectType,
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001641 EnteringContext, Template,
1642 MemberOfUnknownSpecialization);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001643 break;
1644 }
1645
Douglas Gregor014e88d2009-11-03 23:16:33 +00001646 case UnqualifiedId::IK_DestructorName: {
1647 UnqualifiedId TemplateName;
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001648 bool MemberOfUnknownSpecialization;
Douglas Gregor014e88d2009-11-03 23:16:33 +00001649 TemplateName.setIdentifier(Name, NameLoc);
Douglas Gregor2d1c2142009-11-03 19:44:04 +00001650 if (ObjectType) {
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001651 TNK = Actions.ActOnDependentTemplateName(getCurScope(),
1652 SS, TemplateKWLoc, TemplateName,
1653 ObjectType, EnteringContext,
1654 Template);
Douglas Gregord6ab2322010-06-16 23:00:59 +00001655 if (TNK == TNK_Non_template)
Douglas Gregor2d1c2142009-11-03 19:44:04 +00001656 return true;
1657 } else {
Abramo Bagnara7c153532010-08-06 12:11:11 +00001658 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
1659 TemplateName, ObjectType,
Douglas Gregor1fd6d442010-05-21 23:18:07 +00001660 EnteringContext, Template,
1661 MemberOfUnknownSpecialization);
Douglas Gregor2d1c2142009-11-03 19:44:04 +00001662
John McCallb3d87482010-08-24 05:47:05 +00001663 if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
Douglas Gregor124b8782010-02-16 19:09:40 +00001664 Diag(NameLoc, diag::err_destructor_template_id)
1665 << Name << SS.getRange();
Douglas Gregor2d1c2142009-11-03 19:44:04 +00001666 return true;
1667 }
1668 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001669 break;
Douglas Gregor014e88d2009-11-03 23:16:33 +00001670 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001671
1672 default:
1673 return false;
1674 }
1675
1676 if (TNK == TNK_Non_template)
1677 return false;
1678
1679 // Parse the enclosed template argument list.
1680 SourceLocation LAngleLoc, RAngleLoc;
1681 TemplateArgList TemplateArgs;
Douglas Gregor0278e122010-05-05 05:58:24 +00001682 if (Tok.is(tok::less) &&
1683 ParseTemplateIdAfterTemplateName(Template, Id.StartLocation,
Douglas Gregor059101f2011-03-02 00:47:37 +00001684 SS, true, LAngleLoc,
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001685 TemplateArgs,
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001686 RAngleLoc))
1687 return true;
1688
1689 if (Id.getKind() == UnqualifiedId::IK_Identifier ||
Sean Hunte6252d12009-11-28 08:58:14 +00001690 Id.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
1691 Id.getKind() == UnqualifiedId::IK_LiteralOperatorId) {
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001692 // Form a parsed representation of the template-id to be stored in the
1693 // UnqualifiedId.
1694 TemplateIdAnnotation *TemplateId
Benjamin Kramer13bb7012012-04-14 12:14:03 +00001695 = TemplateIdAnnotation::Allocate(TemplateArgs.size(), TemplateIds);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001696
1697 if (Id.getKind() == UnqualifiedId::IK_Identifier) {
1698 TemplateId->Name = Id.Identifier;
Douglas Gregor014e88d2009-11-03 23:16:33 +00001699 TemplateId->Operator = OO_None;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001700 TemplateId->TemplateNameLoc = Id.StartLocation;
1701 } else {
Douglas Gregor014e88d2009-11-03 23:16:33 +00001702 TemplateId->Name = 0;
1703 TemplateId->Operator = Id.OperatorFunctionId.Operator;
1704 TemplateId->TemplateNameLoc = Id.StartLocation;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001705 }
1706
Douglas Gregor059101f2011-03-02 00:47:37 +00001707 TemplateId->SS = SS;
Benjamin Kramer2b28bf12012-02-19 23:37:39 +00001708 TemplateId->TemplateKWLoc = TemplateKWLoc;
John McCall2b5289b2010-08-23 07:28:44 +00001709 TemplateId->Template = Template;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001710 TemplateId->Kind = TNK;
1711 TemplateId->LAngleLoc = LAngleLoc;
1712 TemplateId->RAngleLoc = RAngleLoc;
Douglas Gregor314b97f2009-11-10 19:49:08 +00001713 ParsedTemplateArgument *Args = TemplateId->getTemplateArgs();
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001714 for (unsigned Arg = 0, ArgEnd = TemplateArgs.size();
Douglas Gregor314b97f2009-11-10 19:49:08 +00001715 Arg != ArgEnd; ++Arg)
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001716 Args[Arg] = TemplateArgs[Arg];
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001717
1718 Id.setTemplateId(TemplateId);
1719 return false;
1720 }
1721
1722 // Bundle the template arguments together.
1723 ASTTemplateArgsPtr TemplateArgsPtr(Actions, TemplateArgs.data(),
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001724 TemplateArgs.size());
Abramo Bagnarafad03b72012-01-27 08:46:19 +00001725
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001726 // Constructor and destructor names.
John McCallf312b1e2010-08-26 23:41:50 +00001727 TypeResult Type
Abramo Bagnara55d23c92012-02-06 14:41:24 +00001728 = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
1729 Template, NameLoc,
Abramo Bagnarafad03b72012-01-27 08:46:19 +00001730 LAngleLoc, TemplateArgsPtr, RAngleLoc,
1731 /*IsCtorOrDtorName=*/true);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001732 if (Type.isInvalid())
1733 return true;
1734
1735 if (Id.getKind() == UnqualifiedId::IK_ConstructorName)
1736 Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
1737 else
1738 Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
1739
1740 return false;
1741}
1742
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001743/// \brief Parse an operator-function-id or conversion-function-id as part
1744/// of a C++ unqualified-id.
1745///
1746/// This routine is responsible only for parsing the operator-function-id or
1747/// conversion-function-id; it does not handle template arguments in any way.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001748///
1749/// \code
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001750/// operator-function-id: [C++ 13.5]
1751/// 'operator' operator
1752///
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001753/// operator: one of
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001754/// new delete new[] delete[]
1755/// + - * / % ^ & | ~
1756/// ! = < > += -= *= /= %=
1757/// ^= &= |= << >> >>= <<= == !=
1758/// <= >= && || ++ -- , ->* ->
1759/// () []
1760///
1761/// conversion-function-id: [C++ 12.3.2]
1762/// operator conversion-type-id
1763///
1764/// conversion-type-id:
1765/// type-specifier-seq conversion-declarator[opt]
1766///
1767/// conversion-declarator:
1768/// ptr-operator conversion-declarator[opt]
1769/// \endcode
1770///
1771/// \param The nested-name-specifier that preceded this unqualified-id. If
1772/// non-empty, then we are parsing the unqualified-id of a qualified-id.
1773///
1774/// \param EnteringContext whether we are entering the scope of the
1775/// nested-name-specifier.
1776///
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001777/// \param ObjectType if this unqualified-id occurs within a member access
1778/// expression, the type of the base object whose member is being accessed.
1779///
1780/// \param Result on a successful parse, contains the parsed unqualified-id.
1781///
1782/// \returns true if parsing fails, false otherwise.
1783bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
John McCallb3d87482010-08-24 05:47:05 +00001784 ParsedType ObjectType,
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001785 UnqualifiedId &Result) {
1786 assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
1787
1788 // Consume the 'operator' keyword.
1789 SourceLocation KeywordLoc = ConsumeToken();
1790
1791 // Determine what kind of operator name we have.
1792 unsigned SymbolIdx = 0;
1793 SourceLocation SymbolLocations[3];
1794 OverloadedOperatorKind Op = OO_None;
1795 switch (Tok.getKind()) {
1796 case tok::kw_new:
1797 case tok::kw_delete: {
1798 bool isNew = Tok.getKind() == tok::kw_new;
1799 // Consume the 'new' or 'delete'.
1800 SymbolLocations[SymbolIdx++] = ConsumeToken();
Richard Smith6ee326a2012-04-10 01:32:12 +00001801 // Check for array new/delete.
1802 if (Tok.is(tok::l_square) &&
1803 (!getLangOpts().CPlusPlus0x || NextToken().isNot(tok::l_square))) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001804 // Consume the '[' and ']'.
1805 BalancedDelimiterTracker T(*this, tok::l_square);
1806 T.consumeOpen();
1807 T.consumeClose();
1808 if (T.getCloseLocation().isInvalid())
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001809 return true;
1810
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001811 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
1812 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001813 Op = isNew? OO_Array_New : OO_Array_Delete;
1814 } else {
1815 Op = isNew? OO_New : OO_Delete;
1816 }
1817 break;
1818 }
1819
1820#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1821 case tok::Token: \
1822 SymbolLocations[SymbolIdx++] = ConsumeToken(); \
1823 Op = OO_##Name; \
1824 break;
1825#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
1826#include "clang/Basic/OperatorKinds.def"
1827
1828 case tok::l_paren: {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001829 // Consume the '(' and ')'.
1830 BalancedDelimiterTracker T(*this, tok::l_paren);
1831 T.consumeOpen();
1832 T.consumeClose();
1833 if (T.getCloseLocation().isInvalid())
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001834 return true;
1835
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001836 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
1837 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001838 Op = OO_Call;
1839 break;
1840 }
1841
1842 case tok::l_square: {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001843 // Consume the '[' and ']'.
1844 BalancedDelimiterTracker T(*this, tok::l_square);
1845 T.consumeOpen();
1846 T.consumeClose();
1847 if (T.getCloseLocation().isInvalid())
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001848 return true;
1849
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001850 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
1851 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001852 Op = OO_Subscript;
1853 break;
1854 }
1855
1856 case tok::code_completion: {
1857 // Code completion for the operator name.
Douglas Gregor23c94db2010-07-02 17:43:08 +00001858 Actions.CodeCompleteOperatorName(getCurScope());
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00001859 cutOffParsing();
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001860 // Don't try to parse any further.
1861 return true;
1862 }
1863
1864 default:
1865 break;
1866 }
1867
1868 if (Op != OO_None) {
1869 // We have parsed an operator-function-id.
1870 Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
1871 return false;
1872 }
Sean Hunt0486d742009-11-28 04:44:28 +00001873
1874 // Parse a literal-operator-id.
1875 //
1876 // literal-operator-id: [C++0x 13.5.8]
1877 // operator "" identifier
1878
David Blaikie4e4d0842012-03-11 07:00:24 +00001879 if (getLangOpts().CPlusPlus0x && isTokenStringLiteral()) {
Richard Smith7fe62082011-10-15 05:09:34 +00001880 Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
Sean Hunt0486d742009-11-28 04:44:28 +00001881
Richard Smith33762772012-03-08 23:06:02 +00001882 SourceLocation DiagLoc;
1883 unsigned DiagId = 0;
1884
1885 // We're past translation phase 6, so perform string literal concatenation
1886 // before checking for "".
1887 llvm::SmallVector<Token, 4> Toks;
1888 llvm::SmallVector<SourceLocation, 4> TokLocs;
1889 while (isTokenStringLiteral()) {
1890 if (!Tok.is(tok::string_literal) && !DiagId) {
1891 DiagLoc = Tok.getLocation();
1892 DiagId = diag::err_literal_operator_string_prefix;
1893 }
1894 Toks.push_back(Tok);
1895 TokLocs.push_back(ConsumeStringToken());
1896 }
1897
1898 StringLiteralParser Literal(Toks.data(), Toks.size(), PP);
1899 if (Literal.hadError)
1900 return true;
1901
1902 // Grab the literal operator's suffix, which will be either the next token
1903 // or a ud-suffix from the string literal.
1904 IdentifierInfo *II = 0;
1905 SourceLocation SuffixLoc;
1906 if (!Literal.getUDSuffix().empty()) {
1907 II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
1908 SuffixLoc =
1909 Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
1910 Literal.getUDSuffixOffset(),
David Blaikie4e4d0842012-03-11 07:00:24 +00001911 PP.getSourceManager(), getLangOpts());
Richard Smith33762772012-03-08 23:06:02 +00001912 // This form is not permitted by the standard (yet).
1913 DiagLoc = SuffixLoc;
1914 DiagId = diag::err_literal_operator_missing_space;
1915 } else if (Tok.is(tok::identifier)) {
1916 II = Tok.getIdentifierInfo();
1917 SuffixLoc = ConsumeToken();
1918 TokLocs.push_back(SuffixLoc);
1919 } else {
Sean Hunt0486d742009-11-28 04:44:28 +00001920 Diag(Tok.getLocation(), diag::err_expected_ident);
1921 return true;
1922 }
1923
Richard Smith33762772012-03-08 23:06:02 +00001924 // The string literal must be empty.
1925 if (!Literal.GetString().empty() || Literal.Pascal) {
1926 DiagLoc = TokLocs.front();
1927 DiagId = diag::err_literal_operator_string_not_empty;
1928 }
1929
1930 if (DiagId) {
1931 // This isn't a valid literal-operator-id, but we think we know
1932 // what the user meant. Tell them what they should have written.
1933 llvm::SmallString<32> Str;
1934 Str += "\"\" ";
1935 Str += II->getName();
1936 Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
1937 SourceRange(TokLocs.front(), TokLocs.back()), Str);
1938 }
1939
1940 Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
Sean Hunt3e518bd2009-11-29 07:34:05 +00001941 return false;
Sean Hunt0486d742009-11-28 04:44:28 +00001942 }
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001943
1944 // Parse a conversion-function-id.
1945 //
1946 // conversion-function-id: [C++ 12.3.2]
1947 // operator conversion-type-id
1948 //
1949 // conversion-type-id:
1950 // type-specifier-seq conversion-declarator[opt]
1951 //
1952 // conversion-declarator:
1953 // ptr-operator conversion-declarator[opt]
1954
1955 // Parse the type-specifier-seq.
John McCall0b7e6782011-03-24 11:26:52 +00001956 DeclSpec DS(AttrFactory);
Douglas Gregorf6e6fc82009-11-20 22:03:38 +00001957 if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001958 return true;
1959
1960 // Parse the conversion-declarator, which is merely a sequence of
1961 // ptr-operators.
1962 Declarator D(DS, Declarator::TypeNameContext);
1963 ParseDeclaratorInternal(D, /*DirectDeclParser=*/0);
1964
1965 // Finish up the type.
John McCallf312b1e2010-08-26 23:41:50 +00001966 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
Douglas Gregorca1bdd72009-11-04 00:56:37 +00001967 if (Ty.isInvalid())
1968 return true;
1969
1970 // Note that this is a conversion-function-id.
1971 Result.setConversionFunctionId(KeywordLoc, Ty.get(),
1972 D.getSourceRange().getEnd());
1973 return false;
1974}
1975
1976/// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
1977/// name of an entity.
1978///
1979/// \code
1980/// unqualified-id: [C++ expr.prim.general]
1981/// identifier
1982/// operator-function-id
1983/// conversion-function-id
1984/// [C++0x] literal-operator-id [TODO]
1985/// ~ class-name
1986/// template-id
1987///
1988/// \endcode
1989///
1990/// \param The nested-name-specifier that preceded this unqualified-id. If
1991/// non-empty, then we are parsing the unqualified-id of a qualified-id.
1992///
1993/// \param EnteringContext whether we are entering the scope of the
1994/// nested-name-specifier.
1995///
Douglas Gregor3f9a0562009-11-03 01:35:08 +00001996/// \param AllowDestructorName whether we allow parsing of a destructor name.
1997///
1998/// \param AllowConstructorName whether we allow parsing a constructor name.
1999///
Douglas Gregor46df8cc2009-11-03 21:24:04 +00002000/// \param ObjectType if this unqualified-id occurs within a member access
2001/// expression, the type of the base object whose member is being accessed.
2002///
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002003/// \param Result on a successful parse, contains the parsed unqualified-id.
2004///
2005/// \returns true if parsing fails, false otherwise.
2006bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2007 bool AllowDestructorName,
2008 bool AllowConstructorName,
John McCallb3d87482010-08-24 05:47:05 +00002009 ParsedType ObjectType,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002010 SourceLocation& TemplateKWLoc,
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002011 UnqualifiedId &Result) {
Douglas Gregor0278e122010-05-05 05:58:24 +00002012
2013 // Handle 'A::template B'. This is for template-ids which have not
2014 // already been annotated by ParseOptionalCXXScopeSpecifier().
2015 bool TemplateSpecified = false;
David Blaikie4e4d0842012-03-11 07:00:24 +00002016 if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
Douglas Gregor0278e122010-05-05 05:58:24 +00002017 (ObjectType || SS.isSet())) {
2018 TemplateSpecified = true;
2019 TemplateKWLoc = ConsumeToken();
2020 }
2021
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002022 // unqualified-id:
2023 // identifier
2024 // template-id (when it hasn't already been annotated)
2025 if (Tok.is(tok::identifier)) {
2026 // Consume the identifier.
2027 IdentifierInfo *Id = Tok.getIdentifierInfo();
2028 SourceLocation IdLoc = ConsumeToken();
2029
David Blaikie4e4d0842012-03-11 07:00:24 +00002030 if (!getLangOpts().CPlusPlus) {
Douglas Gregorb862b8f2010-01-11 23:29:10 +00002031 // If we're not in C++, only identifiers matter. Record the
2032 // identifier and return.
2033 Result.setIdentifier(Id, IdLoc);
2034 return false;
2035 }
2036
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002037 if (AllowConstructorName &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002038 Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002039 // We have parsed a constructor name.
Abramo Bagnarafad03b72012-01-27 08:46:19 +00002040 ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(),
2041 &SS, false, false,
2042 ParsedType(),
2043 /*IsCtorOrDtorName=*/true,
2044 /*NonTrivialTypeSourceInfo=*/true);
2045 Result.setConstructorName(Ty, IdLoc, IdLoc);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002046 } else {
2047 // We have parsed an identifier.
2048 Result.setIdentifier(Id, IdLoc);
2049 }
2050
2051 // If the next token is a '<', we may have a template.
Douglas Gregor0278e122010-05-05 05:58:24 +00002052 if (TemplateSpecified || Tok.is(tok::less))
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002053 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2054 EnteringContext, ObjectType,
2055 Result, TemplateSpecified);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002056
2057 return false;
2058 }
2059
2060 // unqualified-id:
2061 // template-id (already parsed and annotated)
2062 if (Tok.is(tok::annot_template_id)) {
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +00002063 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002064
2065 // If the template-name names the current class, then this is a constructor
2066 if (AllowConstructorName && TemplateId->Name &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002067 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002068 if (SS.isSet()) {
2069 // C++ [class.qual]p2 specifies that a qualified template-name
2070 // is taken as the constructor name where a constructor can be
2071 // declared. Thus, the template arguments are extraneous, so
2072 // complain about them and remove them entirely.
2073 Diag(TemplateId->TemplateNameLoc,
2074 diag::err_out_of_line_constructor_template_id)
2075 << TemplateId->Name
Douglas Gregor849b2432010-03-31 17:46:05 +00002076 << FixItHint::CreateRemoval(
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002077 SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
Abramo Bagnarafad03b72012-01-27 08:46:19 +00002078 ParsedType Ty = Actions.getTypeName(*TemplateId->Name,
2079 TemplateId->TemplateNameLoc,
2080 getCurScope(),
2081 &SS, false, false,
2082 ParsedType(),
2083 /*IsCtorOrDtorName=*/true,
2084 /*NontrivialTypeSourceInfo=*/true);
2085 Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002086 TemplateId->RAngleLoc);
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002087 ConsumeToken();
2088 return false;
2089 }
2090
2091 Result.setConstructorTemplateId(TemplateId);
2092 ConsumeToken();
2093 return false;
2094 }
2095
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002096 // We have already parsed a template-id; consume the annotation token as
2097 // our unqualified-id.
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002098 Result.setTemplateId(TemplateId);
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002099 TemplateKWLoc = TemplateId->TemplateKWLoc;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002100 ConsumeToken();
2101 return false;
2102 }
2103
2104 // unqualified-id:
2105 // operator-function-id
2106 // conversion-function-id
2107 if (Tok.is(tok::kw_operator)) {
Douglas Gregorca1bdd72009-11-04 00:56:37 +00002108 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002109 return true;
2110
Sean Hunte6252d12009-11-28 08:58:14 +00002111 // If we have an operator-function-id or a literal-operator-id and the next
2112 // token is a '<', we may have a
Douglas Gregorca1bdd72009-11-04 00:56:37 +00002113 //
2114 // template-id:
2115 // operator-function-id < template-argument-list[opt] >
Sean Hunte6252d12009-11-28 08:58:14 +00002116 if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2117 Result.getKind() == UnqualifiedId::IK_LiteralOperatorId) &&
Douglas Gregor0278e122010-05-05 05:58:24 +00002118 (TemplateSpecified || Tok.is(tok::less)))
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002119 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2120 0, SourceLocation(),
2121 EnteringContext, ObjectType,
2122 Result, TemplateSpecified);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002123
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002124 return false;
2125 }
2126
David Blaikie4e4d0842012-03-11 07:00:24 +00002127 if (getLangOpts().CPlusPlus &&
Douglas Gregorb862b8f2010-01-11 23:29:10 +00002128 (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002129 // C++ [expr.unary.op]p10:
2130 // There is an ambiguity in the unary-expression ~X(), where X is a
2131 // class-name. The ambiguity is resolved in favor of treating ~ as a
2132 // unary complement rather than treating ~X as referring to a destructor.
2133
2134 // Parse the '~'.
2135 SourceLocation TildeLoc = ConsumeToken();
David Blaikie53a75c02011-12-08 16:13:53 +00002136
2137 if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2138 DeclSpec DS(AttrFactory);
2139 SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2140 if (ParsedType Type = Actions.getDestructorType(DS, ObjectType)) {
2141 Result.setDestructorName(TildeLoc, Type, EndLoc);
2142 return false;
2143 }
2144 return true;
2145 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002146
2147 // Parse the class-name.
2148 if (Tok.isNot(tok::identifier)) {
Douglas Gregor124b8782010-02-16 19:09:40 +00002149 Diag(Tok, diag::err_destructor_tilde_identifier);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002150 return true;
2151 }
2152
2153 // Parse the class-name (or template-name in a simple-template-id).
2154 IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2155 SourceLocation ClassNameLoc = ConsumeToken();
2156
Douglas Gregor0278e122010-05-05 05:58:24 +00002157 if (TemplateSpecified || Tok.is(tok::less)) {
John McCallb3d87482010-08-24 05:47:05 +00002158 Result.setDestructorName(TildeLoc, ParsedType(), ClassNameLoc);
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002159 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2160 ClassName, ClassNameLoc,
2161 EnteringContext, ObjectType,
2162 Result, TemplateSpecified);
Douglas Gregor2d1c2142009-11-03 19:44:04 +00002163 }
2164
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002165 // Note that this is a destructor name.
John McCallb3d87482010-08-24 05:47:05 +00002166 ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
2167 ClassNameLoc, getCurScope(),
2168 SS, ObjectType,
2169 EnteringContext);
Douglas Gregor124b8782010-02-16 19:09:40 +00002170 if (!Ty)
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002171 return true;
Douglas Gregor124b8782010-02-16 19:09:40 +00002172
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002173 Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002174 return false;
2175 }
2176
Douglas Gregor2d1c2142009-11-03 19:44:04 +00002177 Diag(Tok, diag::err_expected_unqualified_id)
David Blaikie4e4d0842012-03-11 07:00:24 +00002178 << getLangOpts().CPlusPlus;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00002179 return true;
2180}
2181
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002182/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2183/// memory in a typesafe manner and call constructors.
Mike Stump1eb44332009-09-09 15:08:12 +00002184///
Chris Lattner59232d32009-01-04 21:25:24 +00002185/// This method is called to parse the new expression after the optional :: has
2186/// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
2187/// is its location. Otherwise, "Start" is the location of the 'new' token.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002188///
2189/// new-expression:
2190/// '::'[opt] 'new' new-placement[opt] new-type-id
2191/// new-initializer[opt]
2192/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2193/// new-initializer[opt]
2194///
2195/// new-placement:
2196/// '(' expression-list ')'
2197///
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002198/// new-type-id:
2199/// type-specifier-seq new-declarator[opt]
Douglas Gregor893e1cc2011-04-15 19:40:02 +00002200/// [GNU] attributes type-specifier-seq new-declarator[opt]
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002201///
2202/// new-declarator:
2203/// ptr-operator new-declarator[opt]
2204/// direct-new-declarator
2205///
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002206/// new-initializer:
2207/// '(' expression-list[opt] ')'
Sebastian Redldbef1bb2011-06-05 12:23:16 +00002208/// [C++0x] braced-init-list
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002209///
John McCall60d7b3a2010-08-24 06:29:42 +00002210ExprResult
Chris Lattner59232d32009-01-04 21:25:24 +00002211Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
2212 assert(Tok.is(tok::kw_new) && "expected 'new' token");
2213 ConsumeToken(); // Consume 'new'
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002214
2215 // A '(' now can be a new-placement or the '(' wrapping the type-id in the
2216 // second form of new-expression. It can't be a new-type-id.
2217
Sebastian Redla55e52c2008-11-25 22:21:31 +00002218 ExprVector PlacementArgs(Actions);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002219 SourceLocation PlacementLParen, PlacementRParen;
2220
Douglas Gregor4bd40312010-07-13 15:54:32 +00002221 SourceRange TypeIdParens;
John McCall0b7e6782011-03-24 11:26:52 +00002222 DeclSpec DS(AttrFactory);
Argyrios Kyrtzidis0b8c98f2011-06-28 03:01:23 +00002223 Declarator DeclaratorInfo(DS, Declarator::CXXNewContext);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002224 if (Tok.is(tok::l_paren)) {
2225 // If it turns out to be a placement, we change the type location.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002226 BalancedDelimiterTracker T(*this, tok::l_paren);
2227 T.consumeOpen();
2228 PlacementLParen = T.getOpenLocation();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002229 if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
2230 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
Sebastian Redl20df9b72008-12-11 22:51:44 +00002231 return ExprError();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002232 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002233
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002234 T.consumeClose();
2235 PlacementRParen = T.getCloseLocation();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002236 if (PlacementRParen.isInvalid()) {
2237 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
Sebastian Redl20df9b72008-12-11 22:51:44 +00002238 return ExprError();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002239 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002240
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002241 if (PlacementArgs.empty()) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002242 // Reset the placement locations. There was no placement.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002243 TypeIdParens = T.getRange();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002244 PlacementLParen = PlacementRParen = SourceLocation();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002245 } else {
2246 // We still need the type.
2247 if (Tok.is(tok::l_paren)) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002248 BalancedDelimiterTracker T(*this, tok::l_paren);
2249 T.consumeOpen();
Douglas Gregor893e1cc2011-04-15 19:40:02 +00002250 MaybeParseGNUAttributes(DeclaratorInfo);
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002251 ParseSpecifierQualifierList(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002252 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002253 ParseDeclarator(DeclaratorInfo);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002254 T.consumeClose();
2255 TypeIdParens = T.getRange();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002256 } else {
Douglas Gregor893e1cc2011-04-15 19:40:02 +00002257 MaybeParseGNUAttributes(DeclaratorInfo);
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002258 if (ParseCXXTypeSpecifierSeq(DS))
2259 DeclaratorInfo.setInvalidType(true);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002260 else {
2261 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002262 ParseDeclaratorInternal(DeclaratorInfo,
2263 &Parser::ParseDirectNewDeclarator);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002264 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002265 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002266 }
2267 } else {
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002268 // A new-type-id is a simplified type-id, where essentially the
2269 // direct-declarator is replaced by a direct-new-declarator.
Douglas Gregor893e1cc2011-04-15 19:40:02 +00002270 MaybeParseGNUAttributes(DeclaratorInfo);
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002271 if (ParseCXXTypeSpecifierSeq(DS))
2272 DeclaratorInfo.setInvalidType(true);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002273 else {
2274 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002275 ParseDeclaratorInternal(DeclaratorInfo,
2276 &Parser::ParseDirectNewDeclarator);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002277 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002278 }
Chris Lattnereaaebc72009-04-25 08:06:05 +00002279 if (DeclaratorInfo.isInvalidType()) {
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002280 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
Sebastian Redl20df9b72008-12-11 22:51:44 +00002281 return ExprError();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002282 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002283
Sebastian Redl2aed8b82012-02-16 12:22:20 +00002284 ExprResult Initializer;
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002285
2286 if (Tok.is(tok::l_paren)) {
Sebastian Redl2aed8b82012-02-16 12:22:20 +00002287 SourceLocation ConstructorLParen, ConstructorRParen;
2288 ExprVector ConstructorArgs(Actions);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002289 BalancedDelimiterTracker T(*this, tok::l_paren);
2290 T.consumeOpen();
2291 ConstructorLParen = T.getOpenLocation();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002292 if (Tok.isNot(tok::r_paren)) {
2293 CommaLocsTy CommaLocs;
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002294 if (ParseExpressionList(ConstructorArgs, CommaLocs)) {
2295 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
Sebastian Redl20df9b72008-12-11 22:51:44 +00002296 return ExprError();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002297 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002298 }
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002299 T.consumeClose();
2300 ConstructorRParen = T.getCloseLocation();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002301 if (ConstructorRParen.isInvalid()) {
2302 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
Sebastian Redl20df9b72008-12-11 22:51:44 +00002303 return ExprError();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002304 }
Sebastian Redl2aed8b82012-02-16 12:22:20 +00002305 Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
2306 ConstructorRParen,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002307 ConstructorArgs);
David Blaikie4e4d0842012-03-11 07:00:24 +00002308 } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus0x) {
Richard Smith7fe62082011-10-15 05:09:34 +00002309 Diag(Tok.getLocation(),
2310 diag::warn_cxx98_compat_generalized_initializer_lists);
Sebastian Redl2aed8b82012-02-16 12:22:20 +00002311 Initializer = ParseBraceInitializer();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002312 }
Sebastian Redl2aed8b82012-02-16 12:22:20 +00002313 if (Initializer.isInvalid())
2314 return Initializer;
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002315
Sebastian Redlf53597f2009-03-15 17:47:39 +00002316 return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002317 PlacementArgs, PlacementRParen,
Sebastian Redl2aed8b82012-02-16 12:22:20 +00002318 TypeIdParens, DeclaratorInfo, Initializer.take());
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002319}
2320
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002321/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2322/// passed to ParseDeclaratorInternal.
2323///
2324/// direct-new-declarator:
2325/// '[' expression ']'
2326/// direct-new-declarator '[' constant-expression ']'
2327///
Chris Lattner59232d32009-01-04 21:25:24 +00002328void Parser::ParseDirectNewDeclarator(Declarator &D) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002329 // Parse the array dimensions.
2330 bool first = true;
2331 while (Tok.is(tok::l_square)) {
Richard Smith6ee326a2012-04-10 01:32:12 +00002332 // An array-size expression can't start with a lambda.
2333 if (CheckProhibitedCXX11Attribute())
2334 continue;
2335
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002336 BalancedDelimiterTracker T(*this, tok::l_square);
2337 T.consumeOpen();
2338
John McCall60d7b3a2010-08-24 06:29:42 +00002339 ExprResult Size(first ? ParseExpression()
Sebastian Redl2f7ece72008-12-11 21:36:32 +00002340 : ParseConstantExpression());
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00002341 if (Size.isInvalid()) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002342 // Recover
2343 SkipUntil(tok::r_square);
2344 return;
2345 }
2346 first = false;
2347
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002348 T.consumeClose();
John McCall0b7e6782011-03-24 11:26:52 +00002349
Richard Smith6ee326a2012-04-10 01:32:12 +00002350 // Attributes here appertain to the array type. C++11 [expr.new]p5.
2351 ParsedAttributes Attrs(AttrFactory);
2352 MaybeParseCXX0XAttributes(Attrs);
2353
John McCall0b7e6782011-03-24 11:26:52 +00002354 D.AddTypeInfo(DeclaratorChunk::getArray(0,
John McCall7f040a92010-12-24 02:08:15 +00002355 /*static=*/false, /*star=*/false,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002356 Size.release(),
2357 T.getOpenLocation(),
2358 T.getCloseLocation()),
Richard Smith6ee326a2012-04-10 01:32:12 +00002359 Attrs, T.getCloseLocation());
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002360
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002361 if (T.getCloseLocation().isInvalid())
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002362 return;
2363 }
2364}
2365
2366/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2367/// This ambiguity appears in the syntax of the C++ new operator.
2368///
2369/// new-expression:
2370/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2371/// new-initializer[opt]
2372///
2373/// new-placement:
2374/// '(' expression-list ')'
2375///
John McCallca0408f2010-08-23 06:44:23 +00002376bool Parser::ParseExpressionListOrTypeId(
Chris Lattner5f9e2722011-07-23 10:55:15 +00002377 SmallVectorImpl<Expr*> &PlacementArgs,
Chris Lattner59232d32009-01-04 21:25:24 +00002378 Declarator &D) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002379 // The '(' was already consumed.
2380 if (isTypeIdInParens()) {
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002381 ParseSpecifierQualifierList(D.getMutableDeclSpec());
Sebastian Redlab197ba2009-02-09 18:23:29 +00002382 D.SetSourceRange(D.getDeclSpec().getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +00002383 ParseDeclarator(D);
Chris Lattnereaaebc72009-04-25 08:06:05 +00002384 return D.isInvalidType();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002385 }
2386
2387 // It's not a type, it has to be an expression list.
2388 // Discard the comma locations - ActOnCXXNew has enough parameters.
2389 CommaLocsTy CommaLocs;
2390 return ParseExpressionList(PlacementArgs, CommaLocs);
2391}
2392
2393/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2394/// to free memory allocated by new.
2395///
Chris Lattner59232d32009-01-04 21:25:24 +00002396/// This method is called to parse the 'delete' expression after the optional
2397/// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
2398/// and "Start" is its location. Otherwise, "Start" is the location of the
2399/// 'delete' token.
2400///
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002401/// delete-expression:
2402/// '::'[opt] 'delete' cast-expression
2403/// '::'[opt] 'delete' '[' ']' cast-expression
John McCall60d7b3a2010-08-24 06:29:42 +00002404ExprResult
Chris Lattner59232d32009-01-04 21:25:24 +00002405Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
2406 assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
2407 ConsumeToken(); // Consume 'delete'
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002408
2409 // Array delete?
2410 bool ArrayDelete = false;
Richard Smith6ee326a2012-04-10 01:32:12 +00002411 if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
Richard Smith950435c2012-08-09 19:01:51 +00002412 // C++11 [expr.delete]p1:
2413 // Whenever the delete keyword is followed by empty square brackets, it
2414 // shall be interpreted as [array delete].
2415 // [Footnote: A lambda expression with a lambda-introducer that consists
2416 // of empty square brackets can follow the delete keyword if
2417 // the lambda expression is enclosed in parentheses.]
2418 // FIXME: Produce a better diagnostic if the '[]' is unambiguously a
2419 // lambda-introducer.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002420 ArrayDelete = true;
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002421 BalancedDelimiterTracker T(*this, tok::l_square);
2422
2423 T.consumeOpen();
2424 T.consumeClose();
2425 if (T.getCloseLocation().isInvalid())
Sebastian Redl20df9b72008-12-11 22:51:44 +00002426 return ExprError();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002427 }
2428
John McCall60d7b3a2010-08-24 06:29:42 +00002429 ExprResult Operand(ParseCastExpression(false));
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00002430 if (Operand.isInvalid())
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002431 return Operand;
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002432
John McCall9ae2f072010-08-23 23:25:46 +00002433 return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.take());
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002434}
Sebastian Redl64b45f72009-01-05 20:52:13 +00002435
Mike Stump1eb44332009-09-09 15:08:12 +00002436static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002437 switch(kind) {
David Blaikieb219cfc2011-09-23 05:06:16 +00002438 default: llvm_unreachable("Not a known unary type trait.");
Sebastian Redl64b45f72009-01-05 20:52:13 +00002439 case tok::kw___has_nothrow_assign: return UTT_HasNothrowAssign;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002440 case tok::kw___has_nothrow_constructor: return UTT_HasNothrowConstructor;
John Wiegley20c0da72011-04-27 23:09:49 +00002441 case tok::kw___has_nothrow_copy: return UTT_HasNothrowCopy;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002442 case tok::kw___has_trivial_assign: return UTT_HasTrivialAssign;
Sean Hunt023df372011-05-09 18:22:59 +00002443 case tok::kw___has_trivial_constructor:
2444 return UTT_HasTrivialDefaultConstructor;
John Wiegley20c0da72011-04-27 23:09:49 +00002445 case tok::kw___has_trivial_copy: return UTT_HasTrivialCopy;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002446 case tok::kw___has_trivial_destructor: return UTT_HasTrivialDestructor;
2447 case tok::kw___has_virtual_destructor: return UTT_HasVirtualDestructor;
2448 case tok::kw___is_abstract: return UTT_IsAbstract;
John Wiegley20c0da72011-04-27 23:09:49 +00002449 case tok::kw___is_arithmetic: return UTT_IsArithmetic;
2450 case tok::kw___is_array: return UTT_IsArray;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002451 case tok::kw___is_class: return UTT_IsClass;
John Wiegley20c0da72011-04-27 23:09:49 +00002452 case tok::kw___is_complete_type: return UTT_IsCompleteType;
2453 case tok::kw___is_compound: return UTT_IsCompound;
2454 case tok::kw___is_const: return UTT_IsConst;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002455 case tok::kw___is_empty: return UTT_IsEmpty;
2456 case tok::kw___is_enum: return UTT_IsEnum;
Douglas Gregor5e9392b2011-12-03 18:14:24 +00002457 case tok::kw___is_final: return UTT_IsFinal;
John Wiegley20c0da72011-04-27 23:09:49 +00002458 case tok::kw___is_floating_point: return UTT_IsFloatingPoint;
2459 case tok::kw___is_function: return UTT_IsFunction;
2460 case tok::kw___is_fundamental: return UTT_IsFundamental;
2461 case tok::kw___is_integral: return UTT_IsIntegral;
John Wiegley20c0da72011-04-27 23:09:49 +00002462 case tok::kw___is_lvalue_reference: return UTT_IsLvalueReference;
2463 case tok::kw___is_member_function_pointer: return UTT_IsMemberFunctionPointer;
2464 case tok::kw___is_member_object_pointer: return UTT_IsMemberObjectPointer;
2465 case tok::kw___is_member_pointer: return UTT_IsMemberPointer;
2466 case tok::kw___is_object: return UTT_IsObject;
Chandler Carruth4e61ddd2011-04-23 10:47:20 +00002467 case tok::kw___is_literal: return UTT_IsLiteral;
Chandler Carruth38402812011-04-24 02:49:28 +00002468 case tok::kw___is_literal_type: return UTT_IsLiteral;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002469 case tok::kw___is_pod: return UTT_IsPOD;
John Wiegley20c0da72011-04-27 23:09:49 +00002470 case tok::kw___is_pointer: return UTT_IsPointer;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002471 case tok::kw___is_polymorphic: return UTT_IsPolymorphic;
John Wiegley20c0da72011-04-27 23:09:49 +00002472 case tok::kw___is_reference: return UTT_IsReference;
John Wiegley20c0da72011-04-27 23:09:49 +00002473 case tok::kw___is_rvalue_reference: return UTT_IsRvalueReference;
2474 case tok::kw___is_scalar: return UTT_IsScalar;
2475 case tok::kw___is_signed: return UTT_IsSigned;
2476 case tok::kw___is_standard_layout: return UTT_IsStandardLayout;
2477 case tok::kw___is_trivial: return UTT_IsTrivial;
Sean Huntfeb375d2011-05-13 00:31:07 +00002478 case tok::kw___is_trivially_copyable: return UTT_IsTriviallyCopyable;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002479 case tok::kw___is_union: return UTT_IsUnion;
John Wiegley20c0da72011-04-27 23:09:49 +00002480 case tok::kw___is_unsigned: return UTT_IsUnsigned;
2481 case tok::kw___is_void: return UTT_IsVoid;
2482 case tok::kw___is_volatile: return UTT_IsVolatile;
Sebastian Redl64b45f72009-01-05 20:52:13 +00002483 }
Francois Pichet6ad6f282010-12-07 00:08:36 +00002484}
2485
2486static BinaryTypeTrait BinaryTypeTraitFromTokKind(tok::TokenKind kind) {
2487 switch(kind) {
Francois Pichet38c2b732010-12-07 00:55:57 +00002488 default: llvm_unreachable("Not a known binary type trait");
Francois Pichetf1872372010-12-08 22:35:30 +00002489 case tok::kw___is_base_of: return BTT_IsBaseOf;
John Wiegley20c0da72011-04-27 23:09:49 +00002490 case tok::kw___is_convertible: return BTT_IsConvertible;
2491 case tok::kw___is_same: return BTT_IsSame;
Francois Pichetf1872372010-12-08 22:35:30 +00002492 case tok::kw___builtin_types_compatible_p: return BTT_TypeCompatible;
Douglas Gregor9f361132011-01-27 20:28:01 +00002493 case tok::kw___is_convertible_to: return BTT_IsConvertibleTo;
Douglas Gregor25d0a0f2012-02-23 07:33:15 +00002494 case tok::kw___is_trivially_assignable: return BTT_IsTriviallyAssignable;
Francois Pichet6ad6f282010-12-07 00:08:36 +00002495 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00002496}
2497
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00002498static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
2499 switch (kind) {
2500 default: llvm_unreachable("Not a known type trait");
2501 case tok::kw___is_trivially_constructible:
2502 return TT_IsTriviallyConstructible;
2503 }
2504}
2505
John Wiegley21ff2e52011-04-28 00:16:57 +00002506static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
2507 switch(kind) {
2508 default: llvm_unreachable("Not a known binary type trait");
2509 case tok::kw___array_rank: return ATT_ArrayRank;
2510 case tok::kw___array_extent: return ATT_ArrayExtent;
2511 }
2512}
2513
John Wiegley55262202011-04-25 06:54:41 +00002514static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
2515 switch(kind) {
David Blaikieb219cfc2011-09-23 05:06:16 +00002516 default: llvm_unreachable("Not a known unary expression trait.");
John Wiegley55262202011-04-25 06:54:41 +00002517 case tok::kw___is_lvalue_expr: return ET_IsLValueExpr;
2518 case tok::kw___is_rvalue_expr: return ET_IsRValueExpr;
2519 }
2520}
2521
Sebastian Redl64b45f72009-01-05 20:52:13 +00002522/// ParseUnaryTypeTrait - Parse the built-in unary type-trait
2523/// pseudo-functions that allow implementation of the TR1/C++0x type traits
2524/// templates.
2525///
2526/// primary-expression:
2527/// [GNU] unary-type-trait '(' type-id ')'
2528///
John McCall60d7b3a2010-08-24 06:29:42 +00002529ExprResult Parser::ParseUnaryTypeTrait() {
Sebastian Redl64b45f72009-01-05 20:52:13 +00002530 UnaryTypeTrait UTT = UnaryTypeTraitFromTokKind(Tok.getKind());
2531 SourceLocation Loc = ConsumeToken();
2532
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002533 BalancedDelimiterTracker T(*this, tok::l_paren);
2534 if (T.expectAndConsume(diag::err_expected_lparen))
Sebastian Redl64b45f72009-01-05 20:52:13 +00002535 return ExprError();
2536
2537 // FIXME: Error reporting absolutely sucks! If the this fails to parse a type
2538 // there will be cryptic errors about mismatched parentheses and missing
2539 // specifiers.
Douglas Gregor809070a2009-02-18 17:45:20 +00002540 TypeResult Ty = ParseTypeName();
Sebastian Redl64b45f72009-01-05 20:52:13 +00002541
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002542 T.consumeClose();
Sebastian Redl64b45f72009-01-05 20:52:13 +00002543
Douglas Gregor809070a2009-02-18 17:45:20 +00002544 if (Ty.isInvalid())
2545 return ExprError();
2546
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002547 return Actions.ActOnUnaryTypeTrait(UTT, Loc, Ty.get(), T.getCloseLocation());
Sebastian Redl64b45f72009-01-05 20:52:13 +00002548}
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002549
Francois Pichet6ad6f282010-12-07 00:08:36 +00002550/// ParseBinaryTypeTrait - Parse the built-in binary type-trait
2551/// pseudo-functions that allow implementation of the TR1/C++0x type traits
2552/// templates.
2553///
2554/// primary-expression:
2555/// [GNU] binary-type-trait '(' type-id ',' type-id ')'
2556///
2557ExprResult Parser::ParseBinaryTypeTrait() {
2558 BinaryTypeTrait BTT = BinaryTypeTraitFromTokKind(Tok.getKind());
2559 SourceLocation Loc = ConsumeToken();
2560
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002561 BalancedDelimiterTracker T(*this, tok::l_paren);
2562 if (T.expectAndConsume(diag::err_expected_lparen))
Francois Pichet6ad6f282010-12-07 00:08:36 +00002563 return ExprError();
2564
2565 TypeResult LhsTy = ParseTypeName();
2566 if (LhsTy.isInvalid()) {
2567 SkipUntil(tok::r_paren);
2568 return ExprError();
2569 }
2570
2571 if (ExpectAndConsume(tok::comma, diag::err_expected_comma)) {
2572 SkipUntil(tok::r_paren);
2573 return ExprError();
2574 }
2575
2576 TypeResult RhsTy = ParseTypeName();
2577 if (RhsTy.isInvalid()) {
2578 SkipUntil(tok::r_paren);
2579 return ExprError();
2580 }
2581
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002582 T.consumeClose();
Francois Pichet6ad6f282010-12-07 00:08:36 +00002583
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002584 return Actions.ActOnBinaryTypeTrait(BTT, Loc, LhsTy.get(), RhsTy.get(),
2585 T.getCloseLocation());
Francois Pichet6ad6f282010-12-07 00:08:36 +00002586}
2587
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00002588/// \brief Parse the built-in type-trait pseudo-functions that allow
2589/// implementation of the TR1/C++11 type traits templates.
2590///
2591/// primary-expression:
2592/// type-trait '(' type-id-seq ')'
2593///
2594/// type-id-seq:
2595/// type-id ...[opt] type-id-seq[opt]
2596///
2597ExprResult Parser::ParseTypeTrait() {
2598 TypeTrait Kind = TypeTraitFromTokKind(Tok.getKind());
2599 SourceLocation Loc = ConsumeToken();
2600
2601 BalancedDelimiterTracker Parens(*this, tok::l_paren);
2602 if (Parens.expectAndConsume(diag::err_expected_lparen))
2603 return ExprError();
2604
2605 llvm::SmallVector<ParsedType, 2> Args;
2606 do {
2607 // Parse the next type.
2608 TypeResult Ty = ParseTypeName();
2609 if (Ty.isInvalid()) {
2610 Parens.skipToEnd();
2611 return ExprError();
2612 }
2613
2614 // Parse the ellipsis, if present.
2615 if (Tok.is(tok::ellipsis)) {
2616 Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
2617 if (Ty.isInvalid()) {
2618 Parens.skipToEnd();
2619 return ExprError();
2620 }
2621 }
2622
2623 // Add this type to the list of arguments.
2624 Args.push_back(Ty.get());
2625
2626 if (Tok.is(tok::comma)) {
2627 ConsumeToken();
2628 continue;
2629 }
2630
2631 break;
2632 } while (true);
2633
2634 if (Parens.consumeClose())
2635 return ExprError();
2636
2637 return Actions.ActOnTypeTrait(Kind, Loc, Args, Parens.getCloseLocation());
2638}
2639
John Wiegley21ff2e52011-04-28 00:16:57 +00002640/// ParseArrayTypeTrait - Parse the built-in array type-trait
2641/// pseudo-functions.
2642///
2643/// primary-expression:
2644/// [Embarcadero] '__array_rank' '(' type-id ')'
2645/// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
2646///
2647ExprResult Parser::ParseArrayTypeTrait() {
2648 ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
2649 SourceLocation Loc = ConsumeToken();
2650
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002651 BalancedDelimiterTracker T(*this, tok::l_paren);
2652 if (T.expectAndConsume(diag::err_expected_lparen))
John Wiegley21ff2e52011-04-28 00:16:57 +00002653 return ExprError();
2654
2655 TypeResult Ty = ParseTypeName();
2656 if (Ty.isInvalid()) {
2657 SkipUntil(tok::comma);
2658 SkipUntil(tok::r_paren);
2659 return ExprError();
2660 }
2661
2662 switch (ATT) {
2663 case ATT_ArrayRank: {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002664 T.consumeClose();
2665 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), NULL,
2666 T.getCloseLocation());
John Wiegley21ff2e52011-04-28 00:16:57 +00002667 }
2668 case ATT_ArrayExtent: {
2669 if (ExpectAndConsume(tok::comma, diag::err_expected_comma)) {
2670 SkipUntil(tok::r_paren);
2671 return ExprError();
2672 }
2673
2674 ExprResult DimExpr = ParseExpression();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002675 T.consumeClose();
John Wiegley21ff2e52011-04-28 00:16:57 +00002676
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002677 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
2678 T.getCloseLocation());
John Wiegley21ff2e52011-04-28 00:16:57 +00002679 }
John Wiegley21ff2e52011-04-28 00:16:57 +00002680 }
David Blaikie30263482012-01-20 21:50:17 +00002681 llvm_unreachable("Invalid ArrayTypeTrait!");
John Wiegley21ff2e52011-04-28 00:16:57 +00002682}
2683
John Wiegley55262202011-04-25 06:54:41 +00002684/// ParseExpressionTrait - Parse built-in expression-trait
2685/// pseudo-functions like __is_lvalue_expr( xxx ).
2686///
2687/// primary-expression:
2688/// [Embarcadero] expression-trait '(' expression ')'
2689///
2690ExprResult Parser::ParseExpressionTrait() {
2691 ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
2692 SourceLocation Loc = ConsumeToken();
2693
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002694 BalancedDelimiterTracker T(*this, tok::l_paren);
2695 if (T.expectAndConsume(diag::err_expected_lparen))
John Wiegley55262202011-04-25 06:54:41 +00002696 return ExprError();
2697
2698 ExprResult Expr = ParseExpression();
2699
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002700 T.consumeClose();
John Wiegley55262202011-04-25 06:54:41 +00002701
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002702 return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
2703 T.getCloseLocation());
John Wiegley55262202011-04-25 06:54:41 +00002704}
2705
2706
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002707/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
2708/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
2709/// based on the context past the parens.
John McCall60d7b3a2010-08-24 06:29:42 +00002710ExprResult
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002711Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
John McCallb3d87482010-08-24 05:47:05 +00002712 ParsedType &CastTy,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002713 BalancedDelimiterTracker &Tracker) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002714 assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002715 assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
2716 assert(isTypeIdInParens() && "Not a type-id!");
2717
John McCall60d7b3a2010-08-24 06:29:42 +00002718 ExprResult Result(true);
John McCallb3d87482010-08-24 05:47:05 +00002719 CastTy = ParsedType();
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002720
2721 // We need to disambiguate a very ugly part of the C++ syntax:
2722 //
2723 // (T())x; - type-id
2724 // (T())*x; - type-id
2725 // (T())/x; - expression
2726 // (T()); - expression
2727 //
2728 // The bad news is that we cannot use the specialized tentative parser, since
2729 // it can only verify that the thing inside the parens can be parsed as
2730 // type-id, it is not useful for determining the context past the parens.
2731 //
2732 // The good news is that the parser can disambiguate this part without
Argyrios Kyrtzidisa558a892009-05-22 15:12:46 +00002733 // making any unnecessary Action calls.
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002734 //
2735 // It uses a scheme similar to parsing inline methods. The parenthesized
2736 // tokens are cached, the context that follows is determined (possibly by
2737 // parsing a cast-expression), and then we re-introduce the cached tokens
2738 // into the token stream and parse them appropriately.
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002739
Mike Stump1eb44332009-09-09 15:08:12 +00002740 ParenParseOption ParseAs;
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002741 CachedTokens Toks;
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002742
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002743 // Store the tokens of the parentheses. We will parse them after we determine
2744 // the context that follows them.
Argyrios Kyrtzidis14b91622010-04-23 21:20:12 +00002745 if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002746 // We didn't find the ')' we expected.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002747 Tracker.consumeClose();
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002748 return ExprError();
2749 }
2750
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002751 if (Tok.is(tok::l_brace)) {
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002752 ParseAs = CompoundLiteral;
2753 } else {
2754 bool NotCastExpr;
Eli Friedmanb53f08a2009-05-25 19:41:42 +00002755 // FIXME: Special-case ++ and --: "(S())++;" is not a cast-expression
2756 if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
2757 NotCastExpr = true;
2758 } else {
2759 // Try parsing the cast-expression that may follow.
2760 // If it is not a cast-expression, NotCastExpr will be true and no token
2761 // will be consumed.
2762 Result = ParseCastExpression(false/*isUnaryExpression*/,
2763 false/*isAddressofOperand*/,
John McCallb3d87482010-08-24 05:47:05 +00002764 NotCastExpr,
Argyrios Kyrtzidis0a851832011-07-01 22:22:59 +00002765 // type-id has priority.
Kaelyn Uhraincd78e612012-01-25 20:49:08 +00002766 IsTypeCast);
Eli Friedmanb53f08a2009-05-25 19:41:42 +00002767 }
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002768
2769 // If we parsed a cast-expression, it's really a type-id, otherwise it's
2770 // an expression.
2771 ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002772 }
2773
Mike Stump1eb44332009-09-09 15:08:12 +00002774 // The current token should go after the cached tokens.
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002775 Toks.push_back(Tok);
2776 // Re-enter the stored parenthesized tokens into the token stream, so we may
2777 // parse them now.
2778 PP.EnterTokenStream(Toks.data(), Toks.size(),
2779 true/*DisableMacroExpansion*/, false/*OwnsTokens*/);
2780 // Drop the current token and bring the first cached one. It's the same token
2781 // as when we entered this function.
2782 ConsumeAnyToken();
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002783
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002784 if (ParseAs >= CompoundLiteral) {
Argyrios Kyrtzidis0a851832011-07-01 22:22:59 +00002785 // Parse the type declarator.
2786 DeclSpec DS(AttrFactory);
2787 ParseSpecifierQualifierList(DS);
2788 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
2789 ParseDeclarator(DeclaratorInfo);
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002790
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002791 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002792 Tracker.consumeClose();
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002793
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002794 if (ParseAs == CompoundLiteral) {
2795 ExprType = CompoundLiteral;
Argyrios Kyrtzidis0a851832011-07-01 22:22:59 +00002796 TypeResult Ty = ParseTypeName();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002797 return ParseCompoundLiteralExpression(Ty.get(),
2798 Tracker.getOpenLocation(),
2799 Tracker.getCloseLocation());
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002800 }
Mike Stump1eb44332009-09-09 15:08:12 +00002801
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002802 // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
2803 assert(ParseAs == CastExpr);
2804
Argyrios Kyrtzidis0a851832011-07-01 22:22:59 +00002805 if (DeclaratorInfo.isInvalidType())
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002806 return ExprError();
2807
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002808 // Result is what ParseCastExpression returned earlier.
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002809 if (!Result.isInvalid())
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002810 Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
2811 DeclaratorInfo, CastTy,
2812 Tracker.getCloseLocation(), Result.take());
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002813 return Result;
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002814 }
Mike Stump1eb44332009-09-09 15:08:12 +00002815
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002816 // Not a compound literal, and not followed by a cast-expression.
2817 assert(ParseAs == SimpleExpr);
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002818
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002819 ExprType = SimpleExpr;
Argyrios Kyrtzidisf40882a2009-05-22 21:09:47 +00002820 Result = ParseExpression();
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002821 if (!Result.isInvalid() && Tok.is(tok::r_paren))
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002822 Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
2823 Tok.getLocation(), Result.take());
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002824
2825 // Match the ')'.
2826 if (Result.isInvalid()) {
2827 SkipUntil(tok::r_paren);
2828 return ExprError();
2829 }
Mike Stump1eb44332009-09-09 15:08:12 +00002830
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002831 Tracker.consumeClose();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002832 return Result;
Argyrios Kyrtzidisf58f45e2009-05-22 10:24:42 +00002833}