blob: cfe03d7c4d17d2cc2f280d0d4c36a42d03d06792 [file] [log] [blame]
Chris Lattner29375652006-12-04 18:06:35 +00001//===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner29375652006-12-04 18:06:35 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expression parsing implementation for C++.
11//
12//===----------------------------------------------------------------------===//
Vassil Vassilev11ad3392017-03-23 15:11:07 +000013#include "clang/Parse/Parser.h"
Erik Verbruggen888d52a2014-01-15 09:15:43 +000014#include "clang/AST/ASTContext.h"
Chandler Carruth757fcd62014-03-04 10:05:20 +000015#include "clang/AST/DeclTemplate.h"
Eli Friedmanc7c97142012-01-04 02:40:39 +000016#include "clang/Basic/PrettyStackTrace.h"
Richard Smith7d182a72012-03-08 23:06:02 +000017#include "clang/Lex/LiteralSupport.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000018#include "clang/Parse/ParseDiagnostic.h"
Vassil Vassilev11ad3392017-03-23 15:11:07 +000019#include "clang/Parse/RAIIObjectsForParser.h"
John McCall8b0666c2010-08-20 18:27:03 +000020#include "clang/Sema/DeclSpec.h"
21#include "clang/Sema/ParsedTemplate.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000022#include "clang/Sema/Scope.h"
Douglas Gregor7861a802009-11-03 01:35:08 +000023#include "llvm/Support/ErrorHandling.h"
24
Faisal Vali2b391ab2013-09-26 19:54:12 +000025
Chris Lattner29375652006-12-04 18:06:35 +000026using namespace clang;
27
Alp Tokerf990cef2014-01-07 02:35:33 +000028static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
29 switch (Kind) {
30 // template name
31 case tok::unknown: return 0;
32 // casts
33 case tok::kw_const_cast: return 1;
34 case tok::kw_dynamic_cast: return 2;
35 case tok::kw_reinterpret_cast: return 3;
36 case tok::kw_static_cast: return 4;
37 default:
38 llvm_unreachable("Unknown type for digraph error message.");
39 }
40}
41
Richard Smith55858492011-04-14 21:45:45 +000042// Are the two tokens adjacent in the same source file?
Richard Smith7b3f3222012-06-18 06:11:04 +000043bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
Richard Smith55858492011-04-14 21:45:45 +000044 SourceManager &SM = PP.getSourceManager();
45 SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
Argyrios Kyrtzidise6e67de2011-09-19 20:40:19 +000046 SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
Richard Smith55858492011-04-14 21:45:45 +000047 return FirstEnd == SM.getSpellingLoc(Second.getLocation());
48}
49
50// Suggest fixit for "<::" after a cast.
51static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
52 Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
53 // Pull '<:' and ':' off token stream.
54 if (!AtDigraph)
55 PP.Lex(DigraphToken);
56 PP.Lex(ColonToken);
57
58 SourceRange Range;
59 Range.setBegin(DigraphToken.getLocation());
60 Range.setEnd(ColonToken.getLocation());
61 P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
Alp Tokerf990cef2014-01-07 02:35:33 +000062 << SelectDigraphErrorMessage(Kind)
63 << FixItHint::CreateReplacement(Range, "< ::");
Richard Smith55858492011-04-14 21:45:45 +000064
65 // Update token information to reflect their change in token type.
66 ColonToken.setKind(tok::coloncolon);
Argyrios Kyrtzidise6e67de2011-09-19 20:40:19 +000067 ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
Richard Smith55858492011-04-14 21:45:45 +000068 ColonToken.setLength(2);
69 DigraphToken.setKind(tok::less);
70 DigraphToken.setLength(1);
71
72 // Push new tokens back to token stream.
73 PP.EnterToken(ColonToken);
74 if (!AtDigraph)
75 PP.EnterToken(DigraphToken);
76}
77
Richard Trieu01fc0012011-09-19 19:01:00 +000078// Check for '<::' which should be '< ::' instead of '[:' when following
79// a template name.
80void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
81 bool EnteringContext,
82 IdentifierInfo &II, CXXScopeSpec &SS) {
Richard Trieu02e25db2011-09-20 20:03:50 +000083 if (!Next.is(tok::l_square) || Next.getLength() != 2)
Richard Trieu01fc0012011-09-19 19:01:00 +000084 return;
85
86 Token SecondToken = GetLookAheadToken(2);
Richard Smith7b3f3222012-06-18 06:11:04 +000087 if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
Richard Trieu01fc0012011-09-19 19:01:00 +000088 return;
89
90 TemplateTy Template;
91 UnqualifiedId TemplateName;
92 TemplateName.setIdentifier(&II, Tok.getLocation());
93 bool MemberOfUnknownSpecialization;
94 if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
95 TemplateName, ObjectType, EnteringContext,
96 Template, MemberOfUnknownSpecialization))
97 return;
98
Alp Tokerf990cef2014-01-07 02:35:33 +000099 FixDigraph(*this, PP, Next, SecondToken, tok::unknown,
100 /*AtDigraph*/false);
Richard Trieu01fc0012011-09-19 19:01:00 +0000101}
102
Mike Stump11289f42009-09-09 15:08:12 +0000103/// \brief Parse global scope or nested-name-specifier if present.
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000104///
105/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
Mike Stump11289f42009-09-09 15:08:12 +0000106/// may be preceded by '::'). Note that this routine will not parse ::new or
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000107/// ::delete; it will just leave them in the token stream.
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000108///
109/// '::'[opt] nested-name-specifier
110/// '::'
111///
112/// nested-name-specifier:
113/// type-name '::'
114/// namespace-name '::'
115/// nested-name-specifier identifier '::'
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000116/// nested-name-specifier 'template'[opt] simple-template-id '::'
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000117///
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000118///
Mike Stump11289f42009-09-09 15:08:12 +0000119/// \param SS the scope specifier that will be set to the parsed
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000120/// nested-name-specifier (or empty)
121///
Mike Stump11289f42009-09-09 15:08:12 +0000122/// \param ObjectType if this nested-name-specifier is being parsed following
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000123/// the "." or "->" of a member access expression, this parameter provides the
124/// type of the object whose members are being accessed.
125///
126/// \param EnteringContext whether we will be entering into the context of
127/// the nested-name-specifier after parsing it.
128///
Douglas Gregore610ada2010-02-24 18:44:31 +0000129/// \param MayBePseudoDestructor When non-NULL, points to a flag that
130/// indicates whether this nested-name-specifier may be part of a
131/// pseudo-destructor name. In this case, the flag will be set false
132/// if we don't actually end up parsing a destructor name. Moreorover,
133/// if we do end up determining that we are parsing a destructor name,
134/// the last component of the nested-name-specifier is not parsed as
135/// part of the scope specifier.
Richard Smith7447af42013-03-26 01:15:19 +0000136///
137/// \param IsTypename If \c true, this nested-name-specifier is known to be
138/// part of a type name. This is used to improve error recovery.
139///
140/// \param LastII When non-NULL, points to an IdentifierInfo* that will be
141/// filled in with the leading identifier in the last component of the
142/// nested-name-specifier, if any.
Douglas Gregor90d554e2010-02-21 18:36:56 +0000143///
Matthias Gehredc01bb42017-03-17 21:41:20 +0000144/// \param OnlyNamespace If true, only considers namespaces in lookup.
145///
John McCall1f476a12010-02-26 08:45:28 +0000146/// \returns true if there was an error parsing a scope specifier
Douglas Gregore861bac2009-08-25 22:51:20 +0000147bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
John McCallba7bf592010-08-24 05:47:05 +0000148 ParsedType ObjectType,
Douglas Gregor90d554e2010-02-21 18:36:56 +0000149 bool EnteringContext,
Francois Pichet4e7a2c02011-03-27 19:41:34 +0000150 bool *MayBePseudoDestructor,
Richard Smith7447af42013-03-26 01:15:19 +0000151 bool IsTypename,
Matthias Gehredc01bb42017-03-17 21:41:20 +0000152 IdentifierInfo **LastII,
153 bool OnlyNamespace) {
David Blaikiebbafb8a2012-03-11 07:00:24 +0000154 assert(getLangOpts().CPlusPlus &&
Chris Lattnerb5134c02009-01-05 01:24:05 +0000155 "Call sites of this function should be guarded by checking for C++");
Mike Stump11289f42009-09-09 15:08:12 +0000156
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000157 if (Tok.is(tok::annot_cxxscope)) {
Richard Smith7447af42013-03-26 01:15:19 +0000158 assert(!LastII && "want last identifier but have already annotated scope");
Nico Weberc60aa712015-02-16 22:32:46 +0000159 assert(!MayBePseudoDestructor && "unexpected annot_cxxscope");
Douglas Gregor869ad452011-02-24 17:54:50 +0000160 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
161 Tok.getAnnotationRange(),
162 SS);
Richard Smithaf3b3252017-05-18 19:21:48 +0000163 ConsumeAnnotationToken();
John McCall1f476a12010-02-26 08:45:28 +0000164 return false;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000165 }
Chris Lattnerf9b2cd42009-01-04 21:14:15 +0000166
Larisse Voufob959c3c2013-08-06 05:49:26 +0000167 if (Tok.is(tok::annot_template_id)) {
168 // If the current token is an annotated template id, it may already have
169 // a scope specifier. Restore it.
170 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
171 SS = TemplateId->SS;
172 }
173
Nico Weberc60aa712015-02-16 22:32:46 +0000174 // Has to happen before any "return false"s in this function.
175 bool CheckForDestructor = false;
176 if (MayBePseudoDestructor && *MayBePseudoDestructor) {
177 CheckForDestructor = true;
178 *MayBePseudoDestructor = false;
179 }
180
Richard Smith7447af42013-03-26 01:15:19 +0000181 if (LastII)
Craig Topper161e4db2014-05-21 06:02:52 +0000182 *LastII = nullptr;
Richard Smith7447af42013-03-26 01:15:19 +0000183
Douglas Gregor7f741122009-02-25 19:37:18 +0000184 bool HasScopeSpecifier = false;
185
Chris Lattner8a7d10d2009-01-05 03:55:46 +0000186 if (Tok.is(tok::coloncolon)) {
187 // ::new and ::delete aren't nested-name-specifiers.
188 tok::TokenKind NextKind = NextToken().getKind();
189 if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
190 return false;
Mike Stump11289f42009-09-09 15:08:12 +0000191
David Majnemere8fb28f2014-12-29 19:19:18 +0000192 if (NextKind == tok::l_brace) {
193 // It is invalid to have :: {, consume the scope qualifier and pretend
194 // like we never saw it.
195 Diag(ConsumeToken(), diag::err_expected) << tok::identifier;
196 } else {
197 // '::' - Global scope qualifier.
198 if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS))
199 return true;
Richard Trieu1f3ea7b2012-11-02 01:08:58 +0000200
David Majnemere8fb28f2014-12-29 19:19:18 +0000201 HasScopeSpecifier = true;
202 }
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000203 }
204
Nikola Smiljanic67860242014-09-26 00:28:20 +0000205 if (Tok.is(tok::kw___super)) {
206 SourceLocation SuperLoc = ConsumeToken();
207 if (!Tok.is(tok::coloncolon)) {
208 Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super);
209 return true;
210 }
211
212 return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS);
213 }
214
Richard Smitha9d10012014-10-04 01:57:39 +0000215 if (!HasScopeSpecifier &&
Daniel Marjamakie59f8d72015-06-18 10:59:26 +0000216 Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {
David Blaikie15a430a2011-12-04 05:04:18 +0000217 DeclSpec DS(AttrFactory);
218 SourceLocation DeclLoc = Tok.getLocation();
219 SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
Alp Tokera3ebe6e2013-12-17 14:12:37 +0000220
221 SourceLocation CCLoc;
Richard Smith3f846bd2017-02-08 19:58:48 +0000222 // Work around a standard defect: 'decltype(auto)::' is not a
223 // nested-name-specifier.
224 if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto ||
225 !TryConsumeToken(tok::coloncolon, CCLoc)) {
David Blaikie15a430a2011-12-04 05:04:18 +0000226 AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
227 return false;
228 }
Alp Tokera3ebe6e2013-12-17 14:12:37 +0000229
David Blaikie15a430a2011-12-04 05:04:18 +0000230 if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
231 SS.SetInvalid(SourceRange(DeclLoc, CCLoc));
232
233 HasScopeSpecifier = true;
234 }
235
Douglas Gregor7f741122009-02-25 19:37:18 +0000236 while (true) {
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000237 if (HasScopeSpecifier) {
238 // C++ [basic.lookup.classref]p5:
239 // If the qualified-id has the form
Douglas Gregor308047d2009-09-09 00:23:06 +0000240 //
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000241 // ::class-name-or-namespace-name::...
Douglas Gregor308047d2009-09-09 00:23:06 +0000242 //
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000243 // the class-name-or-namespace-name is looked up in global scope as a
244 // class-name or namespace-name.
245 //
246 // To implement this, we clear out the object type as soon as we've
247 // seen a leading '::' or part of a nested-name-specifier.
David Blaikieefdccaa2016-01-15 23:43:34 +0000248 ObjectType = nullptr;
249
Douglas Gregor2436e712009-09-17 21:32:03 +0000250 if (Tok.is(tok::code_completion)) {
251 // Code completion for a nested-name-specifier, where the code
252 // code completion token follows the '::'.
Douglas Gregor0be31a22010-07-02 17:43:08 +0000253 Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext);
Argyrios Kyrtzidis7d94c922011-04-23 01:04:12 +0000254 // Include code completion token into the range of the scope otherwise
255 // when we try to annotate the scope tokens the dangling code completion
256 // token will cause assertion in
257 // Preprocessor::AnnotatePreviousCachedTokens.
Argyrios Kyrtzidis5cec2ae2011-09-04 03:32:15 +0000258 SS.setEndLoc(Tok.getLocation());
259 cutOffParsing();
260 return true;
Douglas Gregor2436e712009-09-17 21:32:03 +0000261 }
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000262 }
Mike Stump11289f42009-09-09 15:08:12 +0000263
Douglas Gregor7f741122009-02-25 19:37:18 +0000264 // nested-name-specifier:
Chris Lattner0eed3a62009-06-26 03:47:46 +0000265 // nested-name-specifier 'template'[opt] simple-template-id '::'
266
267 // Parse the optional 'template' keyword, then make sure we have
268 // 'identifier <' after it.
269 if (Tok.is(tok::kw_template)) {
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000270 // If we don't have a scope specifier or an object type, this isn't a
Eli Friedman2624be42009-08-29 04:08:08 +0000271 // nested-name-specifier, since they aren't allowed to start with
272 // 'template'.
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000273 if (!HasScopeSpecifier && !ObjectType)
Eli Friedman2624be42009-08-29 04:08:08 +0000274 break;
275
Douglas Gregor120635b2009-11-11 16:39:34 +0000276 TentativeParsingAction TPA(*this);
Chris Lattner0eed3a62009-06-26 03:47:46 +0000277 SourceLocation TemplateKWLoc = ConsumeToken();
Richard Smithd091dc12013-12-05 00:58:33 +0000278
Douglas Gregor71395fa2009-11-04 00:56:37 +0000279 UnqualifiedId TemplateName;
280 if (Tok.is(tok::identifier)) {
Douglas Gregor71395fa2009-11-04 00:56:37 +0000281 // Consume the identifier.
Douglas Gregor120635b2009-11-11 16:39:34 +0000282 TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
Douglas Gregor71395fa2009-11-04 00:56:37 +0000283 ConsumeToken();
284 } else if (Tok.is(tok::kw_operator)) {
Richard Smithd091dc12013-12-05 00:58:33 +0000285 // We don't need to actually parse the unqualified-id in this case,
286 // because a simple-template-id cannot start with 'operator', but
287 // go ahead and parse it anyway for consistency with the case where
288 // we already annotated the template-id.
289 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
Douglas Gregor120635b2009-11-11 16:39:34 +0000290 TemplateName)) {
291 TPA.Commit();
Douglas Gregor71395fa2009-11-04 00:56:37 +0000292 break;
Douglas Gregor120635b2009-11-11 16:39:34 +0000293 }
Richard Smithd091dc12013-12-05 00:58:33 +0000294
Alexis Hunted0530f2009-11-28 08:58:14 +0000295 if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId &&
296 TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) {
Douglas Gregor71395fa2009-11-04 00:56:37 +0000297 Diag(TemplateName.getSourceRange().getBegin(),
298 diag::err_id_after_template_in_nested_name_spec)
299 << TemplateName.getSourceRange();
Douglas Gregor120635b2009-11-11 16:39:34 +0000300 TPA.Commit();
Douglas Gregor71395fa2009-11-04 00:56:37 +0000301 break;
302 }
303 } else {
Douglas Gregor120635b2009-11-11 16:39:34 +0000304 TPA.Revert();
Chris Lattner0eed3a62009-06-26 03:47:46 +0000305 break;
306 }
Mike Stump11289f42009-09-09 15:08:12 +0000307
Douglas Gregor120635b2009-11-11 16:39:34 +0000308 // If the next token is not '<', we have a qualified-id that refers
309 // to a template name, such as T::template apply, but is not a
310 // template-id.
311 if (Tok.isNot(tok::less)) {
312 TPA.Revert();
313 break;
314 }
315
316 // Commit to parsing the template-id.
317 TPA.Commit();
Douglas Gregorbb119652010-06-16 23:00:59 +0000318 TemplateTy Template;
Richard Smithfd3dae02017-01-20 00:20:39 +0000319 if (TemplateNameKind TNK = Actions.ActOnDependentTemplateName(
320 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
321 EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
Abramo Bagnara7945c982012-01-27 09:46:47 +0000322 if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
323 TemplateName, false))
Douglas Gregorbb119652010-06-16 23:00:59 +0000324 return true;
325 } else
John McCall1f476a12010-02-26 08:45:28 +0000326 return true;
Mike Stump11289f42009-09-09 15:08:12 +0000327
Chris Lattner0eed3a62009-06-26 03:47:46 +0000328 continue;
329 }
Mike Stump11289f42009-09-09 15:08:12 +0000330
Douglas Gregor7f741122009-02-25 19:37:18 +0000331 if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
Mike Stump11289f42009-09-09 15:08:12 +0000332 // We have
Douglas Gregor7f741122009-02-25 19:37:18 +0000333 //
Richard Smith72bfbd82013-12-04 00:28:23 +0000334 // template-id '::'
Douglas Gregor7f741122009-02-25 19:37:18 +0000335 //
Richard Smith72bfbd82013-12-04 00:28:23 +0000336 // So we need to check whether the template-id is a simple-template-id of
337 // the right kind (it should name a type or be dependent), and then
Douglas Gregorb67535d2009-03-31 00:43:58 +0000338 // convert it into a type within the nested-name-specifier.
Argyrios Kyrtzidisc0c5dd22011-06-22 06:09:49 +0000339 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregore610ada2010-02-24 18:44:31 +0000340 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
341 *MayBePseudoDestructor = true;
John McCall1f476a12010-02-26 08:45:28 +0000342 return false;
Douglas Gregore610ada2010-02-24 18:44:31 +0000343 }
344
Richard Smith7447af42013-03-26 01:15:19 +0000345 if (LastII)
346 *LastII = TemplateId->Name;
347
Douglas Gregor8b6070b2011-03-04 21:37:14 +0000348 // Consume the template-id token.
Richard Smithaf3b3252017-05-18 19:21:48 +0000349 ConsumeAnnotationToken();
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000350
Douglas Gregor8b6070b2011-03-04 21:37:14 +0000351 assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
352 SourceLocation CCLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +0000353
David Blaikie8c045bc2011-11-07 03:30:03 +0000354 HasScopeSpecifier = true;
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000355
Benjamin Kramercc4c49d2012-08-23 23:38:35 +0000356 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Douglas Gregor8b6070b2011-03-04 21:37:14 +0000357 TemplateId->NumArgs);
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000358
Douglas Gregor8b6070b2011-03-04 21:37:14 +0000359 if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
Abramo Bagnara7945c982012-01-27 09:46:47 +0000360 SS,
361 TemplateId->TemplateKWLoc,
Douglas Gregor8b6070b2011-03-04 21:37:14 +0000362 TemplateId->Template,
363 TemplateId->TemplateNameLoc,
364 TemplateId->LAngleLoc,
365 TemplateArgsPtr,
366 TemplateId->RAngleLoc,
367 CCLoc,
368 EnteringContext)) {
369 SourceLocation StartLoc
370 = SS.getBeginLoc().isValid()? SS.getBeginLoc()
371 : TemplateId->TemplateNameLoc;
372 SS.SetInvalid(SourceRange(StartLoc, CCLoc));
Chris Lattner704edfb2009-06-26 03:45:46 +0000373 }
Argyrios Kyrtzidis13935672011-05-03 18:45:38 +0000374
Douglas Gregor8b6070b2011-03-04 21:37:14 +0000375 continue;
Douglas Gregor7f741122009-02-25 19:37:18 +0000376 }
377
Chris Lattnere2355f72009-06-26 03:52:38 +0000378 // The rest of the nested-name-specifier possibilities start with
379 // tok::identifier.
380 if (Tok.isNot(tok::identifier))
381 break;
382
383 IdentifierInfo &II = *Tok.getIdentifierInfo();
384
385 // nested-name-specifier:
386 // type-name '::'
387 // namespace-name '::'
388 // nested-name-specifier identifier '::'
389 Token Next = NextToken();
Serge Pavlovd931b9f2016-08-08 04:02:15 +0000390 Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(),
391 ObjectType);
392
Chris Lattner1c428032009-12-07 01:36:53 +0000393 // If we get foo:bar, this is almost certainly a typo for foo::bar. Recover
394 // and emit a fixit hint for it.
Douglas Gregor90d554e2010-02-21 18:36:56 +0000395 if (Next.is(tok::colon) && !ColonIsSacred) {
Serge Pavlovd931b9f2016-08-08 04:02:15 +0000396 if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo,
Douglas Gregor90d554e2010-02-21 18:36:56 +0000397 EnteringContext) &&
398 // If the token after the colon isn't an identifier, it's still an
399 // error, but they probably meant something else strange so don't
400 // recover like this.
401 PP.LookAhead(1).is(tok::identifier)) {
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000402 Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
Douglas Gregora771f462010-03-31 17:46:05 +0000403 << FixItHint::CreateReplacement(Next.getLocation(), "::");
Douglas Gregor90d554e2010-02-21 18:36:56 +0000404 // Recover as if the user wrote '::'.
405 Next.setKind(tok::coloncolon);
406 }
Chris Lattner1c428032009-12-07 01:36:53 +0000407 }
David Majnemerf58efd92014-12-29 23:12:23 +0000408
409 if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) {
410 // It is invalid to have :: {, consume the scope qualifier and pretend
411 // like we never saw it.
412 Token Identifier = Tok; // Stash away the identifier.
413 ConsumeToken(); // Eat the identifier, current token is now '::'.
David Majnemerec3f49d2014-12-29 23:24:27 +0000414 Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected)
415 << tok::identifier;
David Majnemerf58efd92014-12-29 23:12:23 +0000416 UnconsumeToken(Identifier); // Stick the identifier back.
417 Next = NextToken(); // Point Next at the '{' token.
418 }
419
Chris Lattnere2355f72009-06-26 03:52:38 +0000420 if (Next.is(tok::coloncolon)) {
Douglas Gregor0d5b0a12010-02-24 21:29:12 +0000421 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) &&
Serge Pavlovd931b9f2016-08-08 04:02:15 +0000422 !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, IdInfo)) {
Douglas Gregore610ada2010-02-24 18:44:31 +0000423 *MayBePseudoDestructor = true;
John McCall1f476a12010-02-26 08:45:28 +0000424 return false;
Douglas Gregore610ada2010-02-24 18:44:31 +0000425 }
426
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000427 if (ColonIsSacred) {
428 const Token &Next2 = GetLookAheadToken(2);
429 if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
430 Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {
431 Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
432 << Next2.getName()
433 << FixItHint::CreateReplacement(Next.getLocation(), ":");
434 Token ColonColon;
435 PP.Lex(ColonColon);
436 ColonColon.setKind(tok::colon);
437 PP.EnterToken(ColonColon);
438 break;
439 }
440 }
441
Richard Smith7447af42013-03-26 01:15:19 +0000442 if (LastII)
443 *LastII = &II;
444
Chris Lattnere2355f72009-06-26 03:52:38 +0000445 // We have an identifier followed by a '::'. Lookup this name
446 // as the name in a nested-name-specifier.
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000447 Token Identifier = Tok;
Chris Lattnere2355f72009-06-26 03:52:38 +0000448 SourceLocation IdLoc = ConsumeToken();
Daniel Marjamakie59f8d72015-06-18 10:59:26 +0000449 assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
Chris Lattner1c428032009-12-07 01:36:53 +0000450 "NextToken() not working properly!");
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000451 Token ColonColon = Tok;
Chris Lattnere2355f72009-06-26 03:52:38 +0000452 SourceLocation CCLoc = ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +0000453
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000454 bool IsCorrectedToColon = false;
Craig Topper161e4db2014-05-21 06:02:52 +0000455 bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
Matthias Gehredc01bb42017-03-17 21:41:20 +0000456 if (Actions.ActOnCXXNestedNameSpecifier(
457 getCurScope(), IdInfo, EnteringContext, SS, false,
458 CorrectionFlagPtr, OnlyNamespace)) {
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000459 // Identifier is not recognized as a nested name, but we can have
460 // mistyped '::' instead of ':'.
461 if (CorrectionFlagPtr && IsCorrectedToColon) {
462 ColonColon.setKind(tok::colon);
463 PP.EnterToken(Tok);
464 PP.EnterToken(ColonColon);
465 Tok = Identifier;
466 break;
467 }
Douglas Gregor90c99722011-02-24 00:17:56 +0000468 SS.SetInvalid(SourceRange(IdLoc, CCLoc));
Serge Pavlov6a7ffbe2014-04-13 16:52:03 +0000469 }
470 HasScopeSpecifier = true;
Chris Lattnere2355f72009-06-26 03:52:38 +0000471 continue;
472 }
Mike Stump11289f42009-09-09 15:08:12 +0000473
Richard Trieu01fc0012011-09-19 19:01:00 +0000474 CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
Richard Smith55858492011-04-14 21:45:45 +0000475
Chris Lattnere2355f72009-06-26 03:52:38 +0000476 // nested-name-specifier:
477 // type-name '<'
478 if (Next.is(tok::less)) {
479 TemplateTy Template;
Douglas Gregor3cf81312009-11-03 23:16:33 +0000480 UnqualifiedId TemplateName;
481 TemplateName.setIdentifier(&II, Tok.getLocation());
Douglas Gregor786123d2010-05-21 23:18:07 +0000482 bool MemberOfUnknownSpecialization;
Douglas Gregor0be31a22010-07-02 17:43:08 +0000483 if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
Abramo Bagnara7c5dee42010-08-06 12:11:11 +0000484 /*hasTemplateKeyword=*/false,
Douglas Gregor3cf81312009-11-03 23:16:33 +0000485 TemplateName,
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000486 ObjectType,
Douglas Gregore861bac2009-08-25 22:51:20 +0000487 EnteringContext,
Douglas Gregor786123d2010-05-21 23:18:07 +0000488 Template,
489 MemberOfUnknownSpecialization)) {
David Blaikie8c045bc2011-11-07 03:30:03 +0000490 // We have found a template name, so annotate this token
Chris Lattnere2355f72009-06-26 03:52:38 +0000491 // with a template-id annotation. We do not permit the
492 // template-id to be translated into a type annotation,
493 // because some clients (e.g., the parsing of class template
494 // specializations) still want to see the original template-id
495 // token.
Douglas Gregor71395fa2009-11-04 00:56:37 +0000496 ConsumeToken();
Abramo Bagnara7945c982012-01-27 09:46:47 +0000497 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
498 TemplateName, false))
John McCall1f476a12010-02-26 08:45:28 +0000499 return true;
Chris Lattnere2355f72009-06-26 03:52:38 +0000500 continue;
Larisse Voufo39a1e502013-08-06 01:03:05 +0000501 }
502
Douglas Gregor20c38a72010-05-21 23:43:39 +0000503 if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
Francois Pichet4e7a2c02011-03-27 19:41:34 +0000504 (IsTypename || IsTemplateArgumentList(1))) {
Douglas Gregor20c38a72010-05-21 23:43:39 +0000505 // We have something like t::getAs<T>, where getAs is a
506 // member of an unknown specialization. However, this will only
507 // parse correctly as a template, so suggest the keyword 'template'
508 // before 'getAs' and treat this as a dependent template name.
Francois Pichet4e7a2c02011-03-27 19:41:34 +0000509 unsigned DiagID = diag::err_missing_dependent_template_keyword;
David Blaikiebbafb8a2012-03-11 07:00:24 +0000510 if (getLangOpts().MicrosoftExt)
Francois Pichet93921652011-04-22 08:25:24 +0000511 DiagID = diag::warn_missing_dependent_template_keyword;
Francois Pichet4e7a2c02011-03-27 19:41:34 +0000512
513 Diag(Tok.getLocation(), DiagID)
Douglas Gregor20c38a72010-05-21 23:43:39 +0000514 << II.getName()
515 << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
Richard Smithfd3dae02017-01-20 00:20:39 +0000516
517 if (TemplateNameKind TNK = Actions.ActOnDependentTemplateName(
518 getCurScope(), SS, SourceLocation(), TemplateName, ObjectType,
519 EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
Douglas Gregorbb119652010-06-16 23:00:59 +0000520 // Consume the identifier.
521 ConsumeToken();
Abramo Bagnara7945c982012-01-27 09:46:47 +0000522 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
523 TemplateName, false))
524 return true;
Douglas Gregorbb119652010-06-16 23:00:59 +0000525 }
526 else
Douglas Gregor20c38a72010-05-21 23:43:39 +0000527 return true;
Douglas Gregorbb119652010-06-16 23:00:59 +0000528
Douglas Gregor20c38a72010-05-21 23:43:39 +0000529 continue;
Chris Lattnere2355f72009-06-26 03:52:38 +0000530 }
531 }
532
Douglas Gregor7f741122009-02-25 19:37:18 +0000533 // We don't have any tokens that form the beginning of a
534 // nested-name-specifier, so we're done.
535 break;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000536 }
Mike Stump11289f42009-09-09 15:08:12 +0000537
Douglas Gregore610ada2010-02-24 18:44:31 +0000538 // Even if we didn't see any pieces of a nested-name-specifier, we
539 // still check whether there is a tilde in this position, which
540 // indicates a potential pseudo-destructor.
541 if (CheckForDestructor && Tok.is(tok::tilde))
542 *MayBePseudoDestructor = true;
543
John McCall1f476a12010-02-26 08:45:28 +0000544 return false;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000545}
546
Kaelyn Takatab16e6322014-11-20 22:06:40 +0000547ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand,
548 Token &Replacement) {
549 SourceLocation TemplateKWLoc;
550 UnqualifiedId Name;
551 if (ParseUnqualifiedId(SS,
552 /*EnteringContext=*/false,
553 /*AllowDestructorName=*/false,
554 /*AllowConstructorName=*/false,
Richard Smith35845152017-02-07 01:37:30 +0000555 /*AllowDeductionGuide=*/false,
David Blaikieefdccaa2016-01-15 23:43:34 +0000556 /*ObjectType=*/nullptr, TemplateKWLoc, Name))
Kaelyn Takatab16e6322014-11-20 22:06:40 +0000557 return ExprError();
558
559 // This is only the direct operand of an & operator if it is not
560 // followed by a postfix-expression suffix.
561 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
562 isAddressOfOperand = false;
563
564 return Actions.ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Name,
565 Tok.is(tok::l_paren), isAddressOfOperand,
566 nullptr, /*IsInlineAsmIdentifier=*/false,
567 &Replacement);
568}
569
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000570/// ParseCXXIdExpression - Handle id-expression.
571///
572/// id-expression:
573/// unqualified-id
574/// qualified-id
575///
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000576/// qualified-id:
577/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
578/// '::' identifier
579/// '::' operator-function-id
Douglas Gregora727cb92009-06-30 22:34:41 +0000580/// '::' template-id
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000581///
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000582/// NOTE: The standard specifies that, for qualified-id, the parser does not
583/// expect:
584///
585/// '::' conversion-function-id
586/// '::' '~' class-name
587///
588/// This may cause a slight inconsistency on diagnostics:
589///
590/// class C {};
591/// namespace A {}
592/// void f() {
593/// :: A :: ~ C(); // Some Sema error about using destructor with a
594/// // namespace.
595/// :: ~ C(); // Some Parser error like 'unexpected ~'.
596/// }
597///
598/// We simplify the parser a bit and make it work like:
599///
600/// qualified-id:
601/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
602/// '::' unqualified-id
603///
604/// That way Sema can handle and report similar errors for namespaces and the
605/// global scope.
606///
Sebastian Redl3d3f75a2009-02-03 20:19:35 +0000607/// The isAddressOfOperand parameter indicates that this id-expression is a
608/// direct operand of the address-of operator. This is, besides member contexts,
609/// the only place where a qualified-id naming a non-static class member may
610/// appear.
611///
John McCalldadc5752010-08-24 06:29:42 +0000612ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000613 // qualified-id:
614 // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
615 // '::' unqualified-id
616 //
617 CXXScopeSpec SS;
David Blaikieefdccaa2016-01-15 23:43:34 +0000618 ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext=*/false);
Abramo Bagnara7945c982012-01-27 09:46:47 +0000619
Kaelyn Takatab16e6322014-11-20 22:06:40 +0000620 Token Replacement;
Nico Weber01a46ad2015-02-15 06:15:40 +0000621 ExprResult Result =
622 tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
Kaelyn Takatab16e6322014-11-20 22:06:40 +0000623 if (Result.isUnset()) {
624 // If the ExprResult is valid but null, then typo correction suggested a
625 // keyword replacement that needs to be reparsed.
626 UnconsumeToken(Replacement);
627 Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
628 }
629 assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "
630 "for a previous keyword suggestion");
631 return Result;
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000632}
633
Richard Smith21b3ab42013-05-09 21:36:41 +0000634/// ParseLambdaExpression - Parse a C++11 lambda expression.
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000635///
636/// lambda-expression:
637/// lambda-introducer lambda-declarator[opt] compound-statement
638///
639/// lambda-introducer:
640/// '[' lambda-capture[opt] ']'
641///
642/// lambda-capture:
643/// capture-default
644/// capture-list
645/// capture-default ',' capture-list
646///
647/// capture-default:
648/// '&'
649/// '='
650///
651/// capture-list:
652/// capture
653/// capture-list ',' capture
654///
655/// capture:
Richard Smith21b3ab42013-05-09 21:36:41 +0000656/// simple-capture
657/// init-capture [C++1y]
658///
659/// simple-capture:
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000660/// identifier
661/// '&' identifier
662/// 'this'
663///
Richard Smith21b3ab42013-05-09 21:36:41 +0000664/// init-capture: [C++1y]
665/// identifier initializer
666/// '&' identifier initializer
667///
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000668/// lambda-declarator:
669/// '(' parameter-declaration-clause ')' attribute-specifier[opt]
670/// 'mutable'[opt] exception-specification[opt]
671/// trailing-return-type[opt]
672///
673ExprResult Parser::ParseLambdaExpression() {
674 // Parse lambda-introducer.
675 LambdaIntroducer Intro;
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000676 Optional<unsigned> DiagID = ParseLambdaIntroducer(Intro);
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000677 if (DiagID) {
678 Diag(Tok, DiagID.getValue());
David Majnemer234b8182015-01-12 03:36:37 +0000679 SkipUntil(tok::r_square, StopAtSemi);
680 SkipUntil(tok::l_brace, StopAtSemi);
681 SkipUntil(tok::r_brace, StopAtSemi);
Eli Friedmanc7c97142012-01-04 02:40:39 +0000682 return ExprError();
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000683 }
684
685 return ParseLambdaExpressionAfterIntroducer(Intro);
686}
687
688/// TryParseLambdaExpression - Use lookahead and potentially tentative
689/// parsing to determine if we are looking at a C++0x lambda expression, and parse
690/// it if we are.
691///
692/// If we are not looking at a lambda expression, returns ExprError().
693ExprResult Parser::TryParseLambdaExpression() {
Richard Smith2bf7fdb2013-01-02 11:42:31 +0000694 assert(getLangOpts().CPlusPlus11
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000695 && Tok.is(tok::l_square)
696 && "Not at the start of a possible lambda expression.");
697
Bruno Cardoso Lopes29b34232016-05-31 18:46:31 +0000698 const Token Next = NextToken();
699 if (Next.is(tok::eof)) // Nothing else to lookup here...
700 return ExprEmpty();
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000701
Bruno Cardoso Lopes29b34232016-05-31 18:46:31 +0000702 const Token After = GetLookAheadToken(2);
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000703 // If lookahead indicates this is a lambda...
704 if (Next.is(tok::r_square) || // []
705 Next.is(tok::equal) || // [=
706 (Next.is(tok::amp) && // [&] or [&,
707 (After.is(tok::r_square) ||
708 After.is(tok::comma))) ||
709 (Next.is(tok::identifier) && // [identifier]
710 After.is(tok::r_square))) {
711 return ParseLambdaExpression();
712 }
713
Eli Friedmanc7c97142012-01-04 02:40:39 +0000714 // If lookahead indicates an ObjC message send...
715 // [identifier identifier
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000716 if (Next.is(tok::identifier) && After.is(tok::identifier)) {
Eli Friedmanc7c97142012-01-04 02:40:39 +0000717 return ExprEmpty();
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000718 }
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000719
Eli Friedmanc7c97142012-01-04 02:40:39 +0000720 // Here, we're stuck: lambda introducers and Objective-C message sends are
721 // unambiguous, but it requires arbitrary lookhead. [a,b,c,d,e,f,g] is a
722 // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send. Instead of
723 // writing two routines to parse a lambda introducer, just try to parse
724 // a lambda introducer first, and fall back if that fails.
725 // (TryParseLambdaIntroducer never produces any diagnostic output.)
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000726 LambdaIntroducer Intro;
727 if (TryParseLambdaIntroducer(Intro))
Eli Friedmanc7c97142012-01-04 02:40:39 +0000728 return ExprEmpty();
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000729
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000730 return ParseLambdaExpressionAfterIntroducer(Intro);
731}
732
Richard Smithf44d2a82013-05-21 22:21:19 +0000733/// \brief Parse a lambda introducer.
734/// \param Intro A LambdaIntroducer filled in with information about the
735/// contents of the lambda-introducer.
736/// \param SkippedInits If non-null, we are disambiguating between an Obj-C
737/// message send and a lambda expression. In this mode, we will
738/// sometimes skip the initializers for init-captures and not fully
739/// populate \p Intro. This flag will be set to \c true if we do so.
740/// \return A DiagnosticID if it hit something unexpected. The location for
Malcolm Parsonsffd21d32017-01-11 11:23:22 +0000741/// the diagnostic is that of the current token.
Richard Smithf44d2a82013-05-21 22:21:19 +0000742Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
743 bool *SkippedInits) {
David Blaikie05785d12013-02-20 22:23:23 +0000744 typedef Optional<unsigned> DiagResult;
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000745
746 assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
Douglas Gregore7a8e3b2011-10-12 16:37:45 +0000747 BalancedDelimiterTracker T(*this, tok::l_square);
748 T.consumeOpen();
749
750 Intro.Range.setBegin(T.getOpenLocation());
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000751
752 bool first = true;
753
754 // Parse capture-default.
755 if (Tok.is(tok::amp) &&
756 (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
757 Intro.Default = LCD_ByRef;
Douglas Gregora1bffa22012-02-10 17:46:20 +0000758 Intro.DefaultLoc = ConsumeToken();
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000759 first = false;
760 } else if (Tok.is(tok::equal)) {
761 Intro.Default = LCD_ByCopy;
Douglas Gregora1bffa22012-02-10 17:46:20 +0000762 Intro.DefaultLoc = ConsumeToken();
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000763 first = false;
764 }
765
766 while (Tok.isNot(tok::r_square)) {
767 if (!first) {
Douglas Gregord8c61782012-02-15 15:34:24 +0000768 if (Tok.isNot(tok::comma)) {
Douglas Gregor721b14d2012-07-31 00:50:07 +0000769 // Provide a completion for a lambda introducer here. Except
770 // in Objective-C, where this is Almost Surely meant to be a message
771 // send. In that case, fail here and let the ObjC message
772 // expression parser perform the completion.
Douglas Gregor2d8db8f2012-07-31 15:27:48 +0000773 if (Tok.is(tok::code_completion) &&
774 !(getLangOpts().ObjC1 && Intro.Default == LCD_None &&
775 !Intro.Captures.empty())) {
Douglas Gregord8c61782012-02-15 15:34:24 +0000776 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
777 /*AfterAmpersand=*/false);
Alp Toker1c583cc2014-05-02 03:43:14 +0000778 cutOffParsing();
Douglas Gregord8c61782012-02-15 15:34:24 +0000779 break;
780 }
781
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000782 return DiagResult(diag::err_expected_comma_or_rsquare);
Douglas Gregord8c61782012-02-15 15:34:24 +0000783 }
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000784 ConsumeToken();
785 }
786
Douglas Gregord8c61782012-02-15 15:34:24 +0000787 if (Tok.is(tok::code_completion)) {
788 // If we're in Objective-C++ and we have a bare '[', then this is more
789 // likely to be a message receiver.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000790 if (getLangOpts().ObjC1 && first)
Douglas Gregord8c61782012-02-15 15:34:24 +0000791 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
792 else
793 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
794 /*AfterAmpersand=*/false);
Alp Toker1c583cc2014-05-02 03:43:14 +0000795 cutOffParsing();
Douglas Gregord8c61782012-02-15 15:34:24 +0000796 break;
797 }
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000798
Douglas Gregord8c61782012-02-15 15:34:24 +0000799 first = false;
800
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000801 // Parse capture.
802 LambdaCaptureKind Kind = LCK_ByCopy;
Richard Smith42b10572015-11-11 01:36:17 +0000803 LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000804 SourceLocation Loc;
Craig Topper161e4db2014-05-21 06:02:52 +0000805 IdentifierInfo *Id = nullptr;
Douglas Gregor3e308b12012-02-14 19:27:52 +0000806 SourceLocation EllipsisLoc;
Richard Smith21b3ab42013-05-09 21:36:41 +0000807 ExprResult Init;
Faisal Validc6b5962016-03-21 09:25:37 +0000808
809 if (Tok.is(tok::star)) {
810 Loc = ConsumeToken();
811 if (Tok.is(tok::kw_this)) {
812 ConsumeToken();
813 Kind = LCK_StarThis;
814 } else {
815 return DiagResult(diag::err_expected_star_this_capture);
816 }
817 } else if (Tok.is(tok::kw_this)) {
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000818 Kind = LCK_This;
819 Loc = ConsumeToken();
820 } else {
821 if (Tok.is(tok::amp)) {
822 Kind = LCK_ByRef;
823 ConsumeToken();
Douglas Gregord8c61782012-02-15 15:34:24 +0000824
825 if (Tok.is(tok::code_completion)) {
826 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
827 /*AfterAmpersand=*/true);
Alp Toker1c583cc2014-05-02 03:43:14 +0000828 cutOffParsing();
Douglas Gregord8c61782012-02-15 15:34:24 +0000829 break;
830 }
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000831 }
832
833 if (Tok.is(tok::identifier)) {
834 Id = Tok.getIdentifierInfo();
835 Loc = ConsumeToken();
836 } else if (Tok.is(tok::kw_this)) {
837 // FIXME: If we want to suggest a fixit here, will need to return more
838 // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be
839 // Clear()ed to prevent emission in case of tentative parsing?
840 return DiagResult(diag::err_this_captured_by_reference);
841 } else {
842 return DiagResult(diag::err_expected_capture);
843 }
Richard Smith21b3ab42013-05-09 21:36:41 +0000844
845 if (Tok.is(tok::l_paren)) {
846 BalancedDelimiterTracker Parens(*this, tok::l_paren);
847 Parens.consumeOpen();
848
Richard Smith42b10572015-11-11 01:36:17 +0000849 InitKind = LambdaCaptureInitKind::DirectInit;
850
Richard Smith21b3ab42013-05-09 21:36:41 +0000851 ExprVector Exprs;
852 CommaLocsTy Commas;
Richard Smithf44d2a82013-05-21 22:21:19 +0000853 if (SkippedInits) {
854 Parens.skipToEnd();
855 *SkippedInits = true;
856 } else if (ParseExpressionList(Exprs, Commas)) {
Richard Smith21b3ab42013-05-09 21:36:41 +0000857 Parens.skipToEnd();
858 Init = ExprError();
859 } else {
860 Parens.consumeClose();
861 Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
862 Parens.getCloseLocation(),
863 Exprs);
864 }
Daniel Marjamakie59f8d72015-06-18 10:59:26 +0000865 } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000866 // Each lambda init-capture forms its own full expression, which clears
867 // Actions.MaybeODRUseExprs. So create an expression evaluation context
868 // to save the necessary state, and restore it later.
Faisal Valid143a0c2017-04-01 21:30:49 +0000869 EnterExpressionEvaluationContext EC(
870 Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
Richard Smith42b10572015-11-11 01:36:17 +0000871
872 if (TryConsumeToken(tok::equal))
873 InitKind = LambdaCaptureInitKind::CopyInit;
874 else
875 InitKind = LambdaCaptureInitKind::ListInit;
Richard Smith21b3ab42013-05-09 21:36:41 +0000876
Richard Smith215f4232015-02-11 02:41:33 +0000877 if (!SkippedInits) {
Richard Smithf44d2a82013-05-21 22:21:19 +0000878 Init = ParseInitializer();
Richard Smith215f4232015-02-11 02:41:33 +0000879 } else if (Tok.is(tok::l_brace)) {
Richard Smithf44d2a82013-05-21 22:21:19 +0000880 BalancedDelimiterTracker Braces(*this, tok::l_brace);
881 Braces.consumeOpen();
882 Braces.skipToEnd();
883 *SkippedInits = true;
884 } else {
885 // We're disambiguating this:
886 //
887 // [..., x = expr
888 //
889 // We need to find the end of the following expression in order to
Richard Smith9e2f0a42014-04-13 04:31:48 +0000890 // determine whether this is an Obj-C message send's receiver, a
891 // C99 designator, or a lambda init-capture.
Richard Smithf44d2a82013-05-21 22:21:19 +0000892 //
893 // Parse the expression to find where it ends, and annotate it back
894 // onto the tokens. We would have parsed this expression the same way
895 // in either case: both the RHS of an init-capture and the RHS of an
896 // assignment expression are parsed as an initializer-clause, and in
897 // neither case can anything be added to the scope between the '[' and
898 // here.
899 //
900 // FIXME: This is horrible. Adding a mechanism to skip an expression
901 // would be much cleaner.
902 // FIXME: If there is a ',' before the next ']' or ':', we can skip to
903 // that instead. (And if we see a ':' with no matching '?', we can
904 // classify this as an Obj-C message send.)
905 SourceLocation StartLoc = Tok.getLocation();
906 InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
907 Init = ParseInitializer();
Akira Hatanaka51e60f92016-12-20 02:11:29 +0000908 if (!Init.isInvalid())
909 Init = Actions.CorrectDelayedTyposInExpr(Init.get());
Richard Smithf44d2a82013-05-21 22:21:19 +0000910
911 if (Tok.getLocation() != StartLoc) {
912 // Back out the lexing of the token after the initializer.
913 PP.RevertCachedTokens(1);
914
915 // Replace the consumed tokens with an appropriate annotation.
916 Tok.setLocation(StartLoc);
917 Tok.setKind(tok::annot_primary_expr);
918 setExprAnnotation(Tok, Init);
919 Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation());
920 PP.AnnotateCachedTokens(Tok);
921
922 // Consume the annotated initializer.
Richard Smithaf3b3252017-05-18 19:21:48 +0000923 ConsumeAnnotationToken();
Richard Smithf44d2a82013-05-21 22:21:19 +0000924 }
925 }
Alp Tokera3ebe6e2013-12-17 14:12:37 +0000926 } else
927 TryConsumeToken(tok::ellipsis, EllipsisLoc);
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000928 }
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000929 // If this is an init capture, process the initialization expression
930 // right away. For lambda init-captures such as the following:
931 // const int x = 10;
932 // auto L = [i = x+1](int a) {
933 // return [j = x+2,
934 // &k = x](char b) { };
935 // };
936 // keep in mind that each lambda init-capture has to have:
937 // - its initialization expression executed in the context
938 // of the enclosing/parent decl-context.
939 // - but the variable itself has to be 'injected' into the
940 // decl-context of its lambda's call-operator (which has
941 // not yet been created).
942 // Each init-expression is a full-expression that has to get
943 // Sema-analyzed (for capturing etc.) before its lambda's
944 // call-operator's decl-context, scope & scopeinfo are pushed on their
945 // respective stacks. Thus if any variable is odr-used in the init-capture
946 // it will correctly get captured in the enclosing lambda, if one exists.
947 // The init-variables above are created later once the lambdascope and
948 // call-operators decl-context is pushed onto its respective stack.
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000949
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000950 // Since the lambda init-capture's initializer expression occurs in the
951 // context of the enclosing function or lambda, therefore we can not wait
952 // till a lambda scope has been pushed on before deciding whether the
953 // variable needs to be captured. We also need to process all
954 // lvalue-to-rvalue conversions and discarded-value conversions,
955 // so that we can avoid capturing certain constant variables.
956 // For e.g.,
957 // void test() {
958 // const int x = 10;
959 // auto L = [&z = x](char a) { <-- don't capture by the current lambda
960 // return [y = x](int i) { <-- don't capture by enclosing lambda
961 // return y;
962 // }
963 // };
Richard Smithbdb84f32016-07-22 23:36:59 +0000964 // }
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000965 // If x was not const, the second use would require 'L' to capture, and
966 // that would be an error.
967
Richard Smith42b10572015-11-11 01:36:17 +0000968 ParsedType InitCaptureType;
Volodymyr Sapsaib0f1aae2017-08-22 17:55:19 +0000969 if (!Init.isInvalid())
970 Init = Actions.CorrectDelayedTyposInExpr(Init.get());
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000971 if (Init.isUsable()) {
972 // Get the pointer and store it in an lvalue, so we can use it as an
973 // out argument.
974 Expr *InitExpr = Init.get();
975 // This performs any lvalue-to-rvalue conversions if necessary, which
976 // can affect what gets captured in the containing decl-context.
Richard Smith42b10572015-11-11 01:36:17 +0000977 InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
978 Loc, Kind == LCK_ByRef, Id, InitKind, InitExpr);
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000979 Init = InitExpr;
Faisal Vali5fb7c3c2013-12-05 01:40:41 +0000980 }
Richard Smith42b10572015-11-11 01:36:17 +0000981 Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
982 InitCaptureType);
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000983 }
984
Douglas Gregore7a8e3b2011-10-12 16:37:45 +0000985 T.consumeClose();
986 Intro.Range.setEnd(T.getCloseLocation());
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000987 return DiagResult();
988}
989
Douglas Gregord8c61782012-02-15 15:34:24 +0000990/// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000991///
992/// Returns true if it hit something unexpected.
993bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
994 TentativeParsingAction PA(*this);
995
Richard Smithf44d2a82013-05-21 22:21:19 +0000996 bool SkippedInits = false;
997 Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro, &SkippedInits));
Douglas Gregordb0b9f12011-08-04 15:30:47 +0000998
999 if (DiagID) {
1000 PA.Revert();
1001 return true;
1002 }
1003
Richard Smithf44d2a82013-05-21 22:21:19 +00001004 if (SkippedInits) {
1005 // Parse it again, but this time parse the init-captures too.
1006 PA.Revert();
1007 Intro = LambdaIntroducer();
1008 DiagID = ParseLambdaIntroducer(Intro);
1009 assert(!DiagID && "parsing lambda-introducer failed on reparse");
1010 return false;
1011 }
1012
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001013 PA.Commit();
1014 return false;
1015}
1016
Faisal Valia734ab92016-03-26 16:11:37 +00001017static void
1018tryConsumeMutableOrConstexprToken(Parser &P, SourceLocation &MutableLoc,
1019 SourceLocation &ConstexprLoc,
1020 SourceLocation &DeclEndLoc) {
1021 assert(MutableLoc.isInvalid());
1022 assert(ConstexprLoc.isInvalid());
1023 // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
1024 // to the final of those locations. Emit an error if we have multiple
1025 // copies of those keywords and recover.
1026
1027 while (true) {
1028 switch (P.getCurToken().getKind()) {
1029 case tok::kw_mutable: {
1030 if (MutableLoc.isValid()) {
1031 P.Diag(P.getCurToken().getLocation(),
1032 diag::err_lambda_decl_specifier_repeated)
1033 << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1034 }
1035 MutableLoc = P.ConsumeToken();
1036 DeclEndLoc = MutableLoc;
1037 break /*switch*/;
1038 }
1039 case tok::kw_constexpr:
1040 if (ConstexprLoc.isValid()) {
1041 P.Diag(P.getCurToken().getLocation(),
1042 diag::err_lambda_decl_specifier_repeated)
1043 << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1044 }
1045 ConstexprLoc = P.ConsumeToken();
1046 DeclEndLoc = ConstexprLoc;
1047 break /*switch*/;
1048 default:
1049 return;
1050 }
1051 }
1052}
1053
1054static void
1055addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
1056 DeclSpec &DS) {
1057 if (ConstexprLoc.isValid()) {
1058 P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus1z
Richard Smithb115e5d2017-08-13 23:37:29 +00001059 ? diag::ext_constexpr_on_lambda_cxx17
Faisal Valia734ab92016-03-26 16:11:37 +00001060 : diag::warn_cxx14_compat_constexpr_on_lambda);
1061 const char *PrevSpec = nullptr;
1062 unsigned DiagID = 0;
1063 DS.SetConstexprSpec(ConstexprLoc, PrevSpec, DiagID);
1064 assert(PrevSpec == nullptr && DiagID == 0 &&
1065 "Constexpr cannot have been set previously!");
1066 }
1067}
1068
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001069/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1070/// expression.
1071ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1072 LambdaIntroducer &Intro) {
Eli Friedmanc7c97142012-01-04 02:40:39 +00001073 SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1074 Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1075
1076 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1077 "lambda expression parsing");
1078
Faisal Vali2b391ab2013-09-26 19:54:12 +00001079
1080
Richard Smith21b3ab42013-05-09 21:36:41 +00001081 // FIXME: Call into Actions to add any init-capture declarations to the
1082 // scope while parsing the lambda-declarator and compound-statement.
1083
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001084 // Parse lambda-declarator[opt].
1085 DeclSpec DS(AttrFactory);
Eli Friedman36d12942012-01-04 04:41:38 +00001086 Declarator D(DS, Declarator::LambdaExprContext);
Faisal Vali2b391ab2013-09-26 19:54:12 +00001087 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
Justin Lebar0fad0ba2016-09-30 17:14:48 +00001088 Actions.PushLambdaScope();
1089
1090 ParsedAttributes Attr(AttrFactory);
1091 SourceLocation DeclLoc = Tok.getLocation();
Justin Lebar0fad0ba2016-09-30 17:14:48 +00001092 if (getLangOpts().CUDA) {
1093 // In CUDA code, GNU attributes are allowed to appear immediately after the
1094 // "[...]", even if there is no "(...)" before the lambda body.
Justin Lebar0139a5d2016-09-30 19:55:48 +00001095 MaybeParseGNUAttributes(D);
Justin Lebar0fad0ba2016-09-30 17:14:48 +00001096 }
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001097
Justin Lebare46ea722016-09-30 19:55:55 +00001098 // Helper to emit a warning if we see a CUDA host/device/global attribute
1099 // after '(...)'. nvcc doesn't accept this.
1100 auto WarnIfHasCUDATargetAttr = [&] {
1101 if (getLangOpts().CUDA)
1102 for (auto *A = Attr.getList(); A != nullptr; A = A->getNext())
1103 if (A->getKind() == AttributeList::AT_CUDADevice ||
1104 A->getKind() == AttributeList::AT_CUDAHost ||
1105 A->getKind() == AttributeList::AT_CUDAGlobal)
1106 Diag(A->getLoc(), diag::warn_cuda_attr_lambda_position)
1107 << A->getName()->getName();
1108 };
1109
David Majnemere01c4662015-01-09 05:10:55 +00001110 TypeResult TrailingReturnType;
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001111 if (Tok.is(tok::l_paren)) {
1112 ParseScope PrototypeScope(this,
1113 Scope::FunctionPrototypeScope |
Richard Smithe233fbf2013-01-28 22:42:45 +00001114 Scope::FunctionDeclarationScope |
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001115 Scope::DeclScope);
1116
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001117 BalancedDelimiterTracker T(*this, tok::l_paren);
1118 T.consumeOpen();
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001119 SourceLocation LParenLoc = T.getOpenLocation();
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001120
1121 // Parse parameter-declaration-clause.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001122 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001123 SourceLocation EllipsisLoc;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001124
1125 if (Tok.isNot(tok::r_paren)) {
Faisal Vali2b391ab2013-09-26 19:54:12 +00001126 Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth);
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001127 ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
Faisal Vali2b391ab2013-09-26 19:54:12 +00001128 // For a generic lambda, each 'auto' within the parameter declaration
1129 // clause creates a template type parameter, so increment the depth.
1130 if (Actions.getCurGenericLambda())
1131 ++CurTemplateDepthTracker;
1132 }
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001133 T.consumeClose();
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001134 SourceLocation RParenLoc = T.getCloseLocation();
Justin Lebar0139a5d2016-09-30 19:55:48 +00001135 SourceLocation DeclEndLoc = RParenLoc;
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001136
Aaron Ballmane8d69b72014-03-12 00:01:07 +00001137 // GNU-style attributes must be parsed before the mutable specifier to be
1138 // compatible with GCC.
1139 MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1140
David Majnemerbda86322015-02-04 08:22:46 +00001141 // MSVC-style attributes must be parsed before the mutable specifier to be
1142 // compatible with MSVC.
Aaron Ballman068aa512015-05-20 20:58:33 +00001143 MaybeParseMicrosoftDeclSpecs(Attr, &DeclEndLoc);
David Majnemerbda86322015-02-04 08:22:46 +00001144
Faisal Valia734ab92016-03-26 16:11:37 +00001145 // Parse mutable-opt and/or constexpr-opt, and update the DeclEndLoc.
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001146 SourceLocation MutableLoc;
Faisal Valia734ab92016-03-26 16:11:37 +00001147 SourceLocation ConstexprLoc;
1148 tryConsumeMutableOrConstexprToken(*this, MutableLoc, ConstexprLoc,
1149 DeclEndLoc);
1150
1151 addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001152
1153 // Parse exception-specification[opt].
1154 ExceptionSpecificationType ESpecType = EST_None;
1155 SourceRange ESpecRange;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001156 SmallVector<ParsedType, 2> DynamicExceptions;
1157 SmallVector<SourceRange, 2> DynamicExceptionRanges;
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001158 ExprResult NoexceptExpr;
Richard Smith0b3a4622014-11-13 20:01:57 +00001159 CachedTokens *ExceptionSpecTokens;
1160 ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
1161 ESpecRange,
Douglas Gregor433e0532012-04-16 18:27:27 +00001162 DynamicExceptions,
1163 DynamicExceptionRanges,
Richard Smith0b3a4622014-11-13 20:01:57 +00001164 NoexceptExpr,
1165 ExceptionSpecTokens);
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001166
1167 if (ESpecType != EST_None)
1168 DeclEndLoc = ESpecRange.getEnd();
1169
1170 // Parse attribute-specifier[opt].
Richard Smith89645bc2013-01-02 12:01:23 +00001171 MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001172
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001173 SourceLocation FunLocalRangeEnd = DeclEndLoc;
1174
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001175 // Parse trailing-return-type[opt].
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001176 if (Tok.is(tok::arrow)) {
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001177 FunLocalRangeEnd = Tok.getLocation();
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001178 SourceRange Range;
Richard Smith700537c2012-06-12 01:51:59 +00001179 TrailingReturnType = ParseTrailingReturnType(Range);
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001180 if (Range.getEnd().isValid())
1181 DeclEndLoc = Range.getEnd();
1182 }
1183
1184 PrototypeScope.Exit();
1185
Justin Lebare46ea722016-09-30 19:55:55 +00001186 WarnIfHasCUDATargetAttr();
1187
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001188 SourceLocation NoLoc;
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001189 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001190 /*isAmbiguous=*/false,
1191 LParenLoc,
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001192 ParamInfo.data(), ParamInfo.size(),
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001193 EllipsisLoc, RParenLoc,
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001194 DS.getTypeQualifiers(),
1195 /*RefQualifierIsLValueRef=*/true,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001196 /*RefQualifierLoc=*/NoLoc,
1197 /*ConstQualifierLoc=*/NoLoc,
1198 /*VolatileQualifierLoc=*/NoLoc,
Hal Finkel23a07392014-10-20 17:32:04 +00001199 /*RestrictQualifierLoc=*/NoLoc,
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001200 MutableLoc,
Nathan Wilsone23a9a42015-08-26 04:19:36 +00001201 ESpecType, ESpecRange,
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001202 DynamicExceptions.data(),
1203 DynamicExceptionRanges.data(),
1204 DynamicExceptions.size(),
1205 NoexceptExpr.isUsable() ?
Craig Topper161e4db2014-05-21 06:02:52 +00001206 NoexceptExpr.get() : nullptr,
Richard Smith0b3a4622014-11-13 20:01:57 +00001207 /*ExceptionSpecTokens*/nullptr,
Reid Kleckner078aea92016-12-09 17:14:05 +00001208 /*DeclsInPrototype=*/None,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001209 LParenLoc, FunLocalRangeEnd, D,
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001210 TrailingReturnType),
1211 Attr, DeclEndLoc);
Faisal Valia734ab92016-03-26 16:11:37 +00001212 } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1213 tok::kw_constexpr) ||
Aaron Ballmanb5c59f52014-03-11 13:03:15 +00001214 (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
1215 // It's common to forget that one needs '()' before 'mutable', an attribute
1216 // specifier, or the result type. Deal with this.
1217 unsigned TokKind = 0;
1218 switch (Tok.getKind()) {
1219 case tok::kw_mutable: TokKind = 0; break;
1220 case tok::arrow: TokKind = 1; break;
Aaron Ballmane8d69b72014-03-12 00:01:07 +00001221 case tok::kw___attribute:
Aaron Ballmanb5c59f52014-03-11 13:03:15 +00001222 case tok::l_square: TokKind = 2; break;
Faisal Valia734ab92016-03-26 16:11:37 +00001223 case tok::kw_constexpr: TokKind = 3; break;
Aaron Ballmanb5c59f52014-03-11 13:03:15 +00001224 default: llvm_unreachable("Unknown token kind");
1225 }
1226
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001227 Diag(Tok, diag::err_lambda_missing_parens)
Aaron Ballmanb5c59f52014-03-11 13:03:15 +00001228 << TokKind
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001229 << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
Justin Lebar0139a5d2016-09-30 19:55:48 +00001230 SourceLocation DeclEndLoc = DeclLoc;
Aaron Ballmane8d69b72014-03-12 00:01:07 +00001231
1232 // GNU-style attributes must be parsed before the mutable specifier to be
1233 // compatible with GCC.
Aaron Ballmane8d69b72014-03-12 00:01:07 +00001234 MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1235
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001236 // Parse 'mutable', if it's there.
1237 SourceLocation MutableLoc;
1238 if (Tok.is(tok::kw_mutable)) {
1239 MutableLoc = ConsumeToken();
1240 DeclEndLoc = MutableLoc;
1241 }
Aaron Ballmanb5c59f52014-03-11 13:03:15 +00001242
1243 // Parse attribute-specifier[opt].
Aaron Ballmanb5c59f52014-03-11 13:03:15 +00001244 MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1245
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001246 // Parse the return type, if there is one.
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001247 if (Tok.is(tok::arrow)) {
1248 SourceRange Range;
Richard Smith700537c2012-06-12 01:51:59 +00001249 TrailingReturnType = ParseTrailingReturnType(Range);
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001250 if (Range.getEnd().isValid())
David Majnemere01c4662015-01-09 05:10:55 +00001251 DeclEndLoc = Range.getEnd();
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001252 }
1253
Justin Lebare46ea722016-09-30 19:55:55 +00001254 WarnIfHasCUDATargetAttr();
1255
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001256 SourceLocation NoLoc;
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001257 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001258 /*isAmbiguous=*/false,
1259 /*LParenLoc=*/NoLoc,
Craig Topper161e4db2014-05-21 06:02:52 +00001260 /*Params=*/nullptr,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001261 /*NumParams=*/0,
1262 /*EllipsisLoc=*/NoLoc,
1263 /*RParenLoc=*/NoLoc,
1264 /*TypeQuals=*/0,
1265 /*RefQualifierIsLValueRef=*/true,
1266 /*RefQualifierLoc=*/NoLoc,
1267 /*ConstQualifierLoc=*/NoLoc,
1268 /*VolatileQualifierLoc=*/NoLoc,
Hal Finkel23a07392014-10-20 17:32:04 +00001269 /*RestrictQualifierLoc=*/NoLoc,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001270 MutableLoc,
1271 EST_None,
Nathan Wilsone23a9a42015-08-26 04:19:36 +00001272 /*ESpecRange=*/SourceRange(),
Craig Topper161e4db2014-05-21 06:02:52 +00001273 /*Exceptions=*/nullptr,
1274 /*ExceptionRanges=*/nullptr,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001275 /*NumExceptions=*/0,
Craig Topper161e4db2014-05-21 06:02:52 +00001276 /*NoexceptExpr=*/nullptr,
Richard Smith0b3a4622014-11-13 20:01:57 +00001277 /*ExceptionSpecTokens=*/nullptr,
Reid Kleckner078aea92016-12-09 17:14:05 +00001278 /*DeclsInPrototype=*/None,
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +00001279 DeclLoc, DeclEndLoc, D,
1280 TrailingReturnType),
Douglas Gregor6746c5d2012-02-16 21:53:36 +00001281 Attr, DeclEndLoc);
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001282 }
1283
Eli Friedman4817cf72012-01-06 03:05:34 +00001284 // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1285 // it.
Momchil Velikov57c681f2017-08-10 15:43:06 +00001286 unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
1287 Scope::CompoundStmtScope;
Douglas Gregorb8389972012-02-21 22:51:27 +00001288 ParseScope BodyScope(this, ScopeFlags);
Eli Friedman4817cf72012-01-06 03:05:34 +00001289
Eli Friedman71c80552012-01-05 03:35:19 +00001290 Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
1291
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001292 // Parse compound-statement.
Eli Friedmanc7c97142012-01-04 02:40:39 +00001293 if (!Tok.is(tok::l_brace)) {
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001294 Diag(Tok, diag::err_expected_lambda_body);
Eli Friedmanc7c97142012-01-04 02:40:39 +00001295 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1296 return ExprError();
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001297 }
1298
Eli Friedmanc7c97142012-01-04 02:40:39 +00001299 StmtResult Stmt(ParseCompoundStatementBody());
1300 BodyScope.Exit();
1301
David Majnemere01c4662015-01-09 05:10:55 +00001302 if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001303 return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
David Majnemere01c4662015-01-09 05:10:55 +00001304
Eli Friedman898caf82012-01-04 02:46:53 +00001305 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1306 return ExprError();
Douglas Gregordb0b9f12011-08-04 15:30:47 +00001307}
1308
Chris Lattner29375652006-12-04 18:06:35 +00001309/// ParseCXXCasts - This handles the various ways to cast expressions to another
1310/// type.
1311///
1312/// postfix-expression: [C++ 5.2p1]
1313/// 'dynamic_cast' '<' type-name '>' '(' expression ')'
1314/// 'static_cast' '<' type-name '>' '(' expression ')'
1315/// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
1316/// 'const_cast' '<' type-name '>' '(' expression ')'
1317///
John McCalldadc5752010-08-24 06:29:42 +00001318ExprResult Parser::ParseCXXCasts() {
Chris Lattner29375652006-12-04 18:06:35 +00001319 tok::TokenKind Kind = Tok.getKind();
Craig Topper161e4db2014-05-21 06:02:52 +00001320 const char *CastName = nullptr; // For error messages
Chris Lattner29375652006-12-04 18:06:35 +00001321
1322 switch (Kind) {
David Blaikieaa347f92011-09-23 20:26:49 +00001323 default: llvm_unreachable("Unknown C++ cast!");
Chris Lattner29375652006-12-04 18:06:35 +00001324 case tok::kw_const_cast: CastName = "const_cast"; break;
1325 case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
1326 case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1327 case tok::kw_static_cast: CastName = "static_cast"; break;
1328 }
1329
1330 SourceLocation OpLoc = ConsumeToken();
1331 SourceLocation LAngleBracketLoc = Tok.getLocation();
1332
Richard Smith55858492011-04-14 21:45:45 +00001333 // Check for "<::" which is parsed as "[:". If found, fix token stream,
1334 // diagnose error, suggest fix, and recover parsing.
Richard Smith62e66302012-08-20 17:37:52 +00001335 if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
1336 Token Next = NextToken();
1337 if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1338 FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1339 }
Richard Smith55858492011-04-14 21:45:45 +00001340
Chris Lattner29375652006-12-04 18:06:35 +00001341 if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
Sebastian Redld65cea82008-12-11 22:51:44 +00001342 return ExprError();
Chris Lattner29375652006-12-04 18:06:35 +00001343
Argyrios Kyrtzidis7451d1c2011-07-01 22:22:50 +00001344 // Parse the common declaration-specifiers piece.
1345 DeclSpec DS(AttrFactory);
1346 ParseSpecifierQualifierList(DS);
1347
1348 // Parse the abstract-declarator, if present.
1349 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1350 ParseDeclarator(DeclaratorInfo);
1351
Chris Lattner29375652006-12-04 18:06:35 +00001352 SourceLocation RAngleBracketLoc = Tok.getLocation();
1353
Alp Toker383d2c42014-01-01 03:08:43 +00001354 if (ExpectAndConsume(tok::greater))
Alp Tokerec543272013-12-24 09:48:30 +00001355 return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
Chris Lattner29375652006-12-04 18:06:35 +00001356
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001357 SourceLocation LParenLoc, RParenLoc;
1358 BalancedDelimiterTracker T(*this, tok::l_paren);
Chris Lattner29375652006-12-04 18:06:35 +00001359
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001360 if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
Argyrios Kyrtzidis387a3342009-05-22 10:23:16 +00001361 return ExprError();
Chris Lattner29375652006-12-04 18:06:35 +00001362
John McCalldadc5752010-08-24 06:29:42 +00001363 ExprResult Result = ParseExpression();
Mike Stump11289f42009-09-09 15:08:12 +00001364
Argyrios Kyrtzidis387a3342009-05-22 10:23:16 +00001365 // Match the ')'.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001366 T.consumeClose();
Chris Lattner29375652006-12-04 18:06:35 +00001367
Argyrios Kyrtzidis7451d1c2011-07-01 22:22:50 +00001368 if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
Douglas Gregore200adc2008-10-27 19:41:14 +00001369 Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
Argyrios Kyrtzidis7451d1c2011-07-01 22:22:50 +00001370 LAngleBracketLoc, DeclaratorInfo,
Douglas Gregor220cac52009-02-18 17:45:20 +00001371 RAngleBracketLoc,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001372 T.getOpenLocation(), Result.get(),
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001373 T.getCloseLocation());
Chris Lattner29375652006-12-04 18:06:35 +00001374
Benjamin Kramer62b95d82012-08-23 21:35:17 +00001375 return Result;
Chris Lattner29375652006-12-04 18:06:35 +00001376}
Bill Wendling4073ed52007-02-13 01:51:42 +00001377
Sebastian Redlc4704762008-11-11 11:37:55 +00001378/// ParseCXXTypeid - This handles the C++ typeid expression.
1379///
1380/// postfix-expression: [C++ 5.2p1]
1381/// 'typeid' '(' expression ')'
1382/// 'typeid' '(' type-id ')'
1383///
John McCalldadc5752010-08-24 06:29:42 +00001384ExprResult Parser::ParseCXXTypeid() {
Sebastian Redlc4704762008-11-11 11:37:55 +00001385 assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
1386
1387 SourceLocation OpLoc = ConsumeToken();
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001388 SourceLocation LParenLoc, RParenLoc;
1389 BalancedDelimiterTracker T(*this, tok::l_paren);
Sebastian Redlc4704762008-11-11 11:37:55 +00001390
1391 // typeid expressions are always parenthesized.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001392 if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
Sebastian Redld65cea82008-12-11 22:51:44 +00001393 return ExprError();
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001394 LParenLoc = T.getOpenLocation();
Sebastian Redlc4704762008-11-11 11:37:55 +00001395
John McCalldadc5752010-08-24 06:29:42 +00001396 ExprResult Result;
Sebastian Redlc4704762008-11-11 11:37:55 +00001397
Richard Smith4f605af2012-08-18 00:55:03 +00001398 // C++0x [expr.typeid]p3:
1399 // When typeid is applied to an expression other than an lvalue of a
1400 // polymorphic class type [...] The expression is an unevaluated
1401 // operand (Clause 5).
1402 //
1403 // Note that we can't tell whether the expression is an lvalue of a
1404 // polymorphic class type until after we've parsed the expression; we
1405 // speculatively assume the subexpression is unevaluated, and fix it up
1406 // later.
1407 //
1408 // We enter the unevaluated context before trying to determine whether we
1409 // have a type-id, because the tentative parse logic will try to resolve
1410 // names, and must treat them as unevaluated.
Faisal Valid143a0c2017-04-01 21:30:49 +00001411 EnterExpressionEvaluationContext Unevaluated(
1412 Actions, Sema::ExpressionEvaluationContext::Unevaluated,
1413 Sema::ReuseLambdaContextDecl);
Richard Smith4f605af2012-08-18 00:55:03 +00001414
Sebastian Redlc4704762008-11-11 11:37:55 +00001415 if (isTypeIdInParens()) {
Douglas Gregor220cac52009-02-18 17:45:20 +00001416 TypeResult Ty = ParseTypeName();
Sebastian Redlc4704762008-11-11 11:37:55 +00001417
1418 // Match the ')'.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001419 T.consumeClose();
1420 RParenLoc = T.getCloseLocation();
Douglas Gregor4c7c1092010-09-08 23:14:30 +00001421 if (Ty.isInvalid() || RParenLoc.isInvalid())
Sebastian Redld65cea82008-12-11 22:51:44 +00001422 return ExprError();
Sebastian Redlc4704762008-11-11 11:37:55 +00001423
1424 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
John McCallba7bf592010-08-24 05:47:05 +00001425 Ty.get().getAsOpaquePtr(), RParenLoc);
Sebastian Redlc4704762008-11-11 11:37:55 +00001426 } else {
1427 Result = ParseExpression();
1428
1429 // Match the ')'.
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001430 if (Result.isInvalid())
Alexey Bataevee6507d2013-11-18 08:17:37 +00001431 SkipUntil(tok::r_paren, StopAtSemi);
Sebastian Redlc4704762008-11-11 11:37:55 +00001432 else {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001433 T.consumeClose();
1434 RParenLoc = T.getCloseLocation();
Douglas Gregor4c7c1092010-09-08 23:14:30 +00001435 if (RParenLoc.isInvalid())
1436 return ExprError();
Douglas Gregor1beec452011-03-12 01:48:56 +00001437
Sebastian Redlc4704762008-11-11 11:37:55 +00001438 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001439 Result.get(), RParenLoc);
Sebastian Redlc4704762008-11-11 11:37:55 +00001440 }
1441 }
1442
Benjamin Kramer62b95d82012-08-23 21:35:17 +00001443 return Result;
Sebastian Redlc4704762008-11-11 11:37:55 +00001444}
1445
Francois Pichet9f4f2072010-09-08 12:20:18 +00001446/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1447///
1448/// '__uuidof' '(' expression ')'
1449/// '__uuidof' '(' type-id ')'
1450///
1451ExprResult Parser::ParseCXXUuidof() {
1452 assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1453
1454 SourceLocation OpLoc = ConsumeToken();
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001455 BalancedDelimiterTracker T(*this, tok::l_paren);
Francois Pichet9f4f2072010-09-08 12:20:18 +00001456
1457 // __uuidof expressions are always parenthesized.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001458 if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
Francois Pichet9f4f2072010-09-08 12:20:18 +00001459 return ExprError();
1460
1461 ExprResult Result;
1462
1463 if (isTypeIdInParens()) {
1464 TypeResult Ty = ParseTypeName();
1465
1466 // Match the ')'.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001467 T.consumeClose();
Francois Pichet9f4f2072010-09-08 12:20:18 +00001468
1469 if (Ty.isInvalid())
1470 return ExprError();
1471
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001472 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1473 Ty.get().getAsOpaquePtr(),
1474 T.getCloseLocation());
Francois Pichet9f4f2072010-09-08 12:20:18 +00001475 } else {
Faisal Valid143a0c2017-04-01 21:30:49 +00001476 EnterExpressionEvaluationContext Unevaluated(
1477 Actions, Sema::ExpressionEvaluationContext::Unevaluated);
Francois Pichet9f4f2072010-09-08 12:20:18 +00001478 Result = ParseExpression();
1479
1480 // Match the ')'.
1481 if (Result.isInvalid())
Alexey Bataevee6507d2013-11-18 08:17:37 +00001482 SkipUntil(tok::r_paren, StopAtSemi);
Francois Pichet9f4f2072010-09-08 12:20:18 +00001483 else {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001484 T.consumeClose();
Francois Pichet9f4f2072010-09-08 12:20:18 +00001485
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001486 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1487 /*isType=*/false,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001488 Result.get(), T.getCloseLocation());
Francois Pichet9f4f2072010-09-08 12:20:18 +00001489 }
1490 }
1491
Benjamin Kramer62b95d82012-08-23 21:35:17 +00001492 return Result;
Francois Pichet9f4f2072010-09-08 12:20:18 +00001493}
1494
Douglas Gregore610ada2010-02-24 18:44:31 +00001495/// \brief Parse a C++ pseudo-destructor expression after the base,
1496/// . or -> operator, and nested-name-specifier have already been
1497/// parsed.
1498///
1499/// postfix-expression: [C++ 5.2]
1500/// postfix-expression . pseudo-destructor-name
1501/// postfix-expression -> pseudo-destructor-name
1502///
1503/// pseudo-destructor-name:
1504/// ::[opt] nested-name-specifier[opt] type-name :: ~type-name
1505/// ::[opt] nested-name-specifier template simple-template-id ::
1506/// ~type-name
1507/// ::[opt] nested-name-specifier[opt] ~type-name
1508///
John McCalldadc5752010-08-24 06:29:42 +00001509ExprResult
Craig Toppera2c51532014-10-30 05:30:05 +00001510Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
Douglas Gregore610ada2010-02-24 18:44:31 +00001511 tok::TokenKind OpKind,
1512 CXXScopeSpec &SS,
John McCallba7bf592010-08-24 05:47:05 +00001513 ParsedType ObjectType) {
Douglas Gregore610ada2010-02-24 18:44:31 +00001514 // We're parsing either a pseudo-destructor-name or a dependent
1515 // member access that has the same form as a
1516 // pseudo-destructor-name. We parse both in the same way and let
1517 // the action model sort them out.
1518 //
1519 // Note that the ::[opt] nested-name-specifier[opt] has already
1520 // been parsed, and if there was a simple-template-id, it has
1521 // been coalesced into a template-id annotation token.
1522 UnqualifiedId FirstTypeName;
1523 SourceLocation CCLoc;
1524 if (Tok.is(tok::identifier)) {
1525 FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1526 ConsumeToken();
1527 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1528 CCLoc = ConsumeToken();
1529 } else if (Tok.is(tok::annot_template_id)) {
Abramo Bagnara7945c982012-01-27 09:46:47 +00001530 // FIXME: retrieve TemplateKWLoc from template-id annotation and
1531 // store it in the pseudo-dtor node (to be used when instantiating it).
Douglas Gregore610ada2010-02-24 18:44:31 +00001532 FirstTypeName.setTemplateId(
1533 (TemplateIdAnnotation *)Tok.getAnnotationValue());
Richard Smithaf3b3252017-05-18 19:21:48 +00001534 ConsumeAnnotationToken();
Douglas Gregore610ada2010-02-24 18:44:31 +00001535 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1536 CCLoc = ConsumeToken();
1537 } else {
Craig Topper161e4db2014-05-21 06:02:52 +00001538 FirstTypeName.setIdentifier(nullptr, SourceLocation());
Douglas Gregore610ada2010-02-24 18:44:31 +00001539 }
1540
1541 // Parse the tilde.
1542 assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1543 SourceLocation TildeLoc = ConsumeToken();
David Blaikie1d578782011-12-16 16:03:09 +00001544
1545 if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
1546 DeclSpec DS(AttrFactory);
Benjamin Kramer198e0832011-12-18 12:18:02 +00001547 ParseDecltypeSpecifier(DS);
David Blaikie1d578782011-12-16 16:03:09 +00001548 if (DS.getTypeSpecType() == TST_error)
1549 return ExprError();
David Majnemerced8bdf2015-02-25 17:36:15 +00001550 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1551 TildeLoc, DS);
David Blaikie1d578782011-12-16 16:03:09 +00001552 }
1553
Douglas Gregore610ada2010-02-24 18:44:31 +00001554 if (!Tok.is(tok::identifier)) {
1555 Diag(Tok, diag::err_destructor_tilde_identifier);
1556 return ExprError();
1557 }
1558
1559 // Parse the second type.
1560 UnqualifiedId SecondTypeName;
1561 IdentifierInfo *Name = Tok.getIdentifierInfo();
1562 SourceLocation NameLoc = ConsumeToken();
1563 SecondTypeName.setIdentifier(Name, NameLoc);
1564
1565 // If there is a '<', the second type name is a template-id. Parse
1566 // it as such.
1567 if (Tok.is(tok::less) &&
Abramo Bagnara7945c982012-01-27 09:46:47 +00001568 ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
1569 Name, NameLoc,
1570 false, ObjectType, SecondTypeName,
1571 /*AssumeTemplateName=*/true))
Douglas Gregore610ada2010-02-24 18:44:31 +00001572 return ExprError();
1573
David Majnemerced8bdf2015-02-25 17:36:15 +00001574 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1575 SS, FirstTypeName, CCLoc, TildeLoc,
1576 SecondTypeName);
Douglas Gregore610ada2010-02-24 18:44:31 +00001577}
1578
Bill Wendling4073ed52007-02-13 01:51:42 +00001579/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1580///
1581/// boolean-literal: [C++ 2.13.5]
1582/// 'true'
1583/// 'false'
John McCalldadc5752010-08-24 06:29:42 +00001584ExprResult Parser::ParseCXXBoolLiteral() {
Bill Wendling4073ed52007-02-13 01:51:42 +00001585 tok::TokenKind Kind = Tok.getKind();
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001586 return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
Bill Wendling4073ed52007-02-13 01:51:42 +00001587}
Chris Lattnerb7e656b2008-02-26 00:51:44 +00001588
1589/// ParseThrowExpression - This handles the C++ throw expression.
1590///
1591/// throw-expression: [C++ 15]
1592/// 'throw' assignment-expression[opt]
John McCalldadc5752010-08-24 06:29:42 +00001593ExprResult Parser::ParseThrowExpression() {
Chris Lattnerb7e656b2008-02-26 00:51:44 +00001594 assert(Tok.is(tok::kw_throw) && "Not throw!");
Chris Lattnerb7e656b2008-02-26 00:51:44 +00001595 SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
Sebastian Redld65cea82008-12-11 22:51:44 +00001596
Chris Lattner65dd8432008-04-06 06:02:23 +00001597 // If the current token isn't the start of an assignment-expression,
1598 // then the expression is not present. This handles things like:
1599 // "C ? throw : (void)42", which is crazy but legal.
1600 switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
1601 case tok::semi:
1602 case tok::r_paren:
1603 case tok::r_square:
1604 case tok::r_brace:
1605 case tok::colon:
1606 case tok::comma:
Craig Topper161e4db2014-05-21 06:02:52 +00001607 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
Chris Lattnerb7e656b2008-02-26 00:51:44 +00001608
Chris Lattner65dd8432008-04-06 06:02:23 +00001609 default:
John McCalldadc5752010-08-24 06:29:42 +00001610 ExprResult Expr(ParseAssignmentExpression());
Benjamin Kramer62b95d82012-08-23 21:35:17 +00001611 if (Expr.isInvalid()) return Expr;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001612 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
Chris Lattner65dd8432008-04-06 06:02:23 +00001613 }
Chris Lattnerb7e656b2008-02-26 00:51:44 +00001614}
Argyrios Kyrtzidis7bbb20e2008-06-24 22:12:16 +00001615
Richard Smith0e304ea2015-10-22 04:46:14 +00001616/// \brief Parse the C++ Coroutines co_yield expression.
1617///
1618/// co_yield-expression:
1619/// 'co_yield' assignment-expression[opt]
1620ExprResult Parser::ParseCoyieldExpression() {
1621 assert(Tok.is(tok::kw_co_yield) && "Not co_yield!");
1622
1623 SourceLocation Loc = ConsumeToken();
Richard Smithae3d1472015-11-20 22:47:10 +00001624 ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
1625 : ParseAssignmentExpression();
Richard Smithcfd53b42015-10-22 06:13:50 +00001626 if (!Expr.isInvalid())
Richard Smith9f690bd2015-10-27 06:02:45 +00001627 Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
Richard Smith0e304ea2015-10-22 04:46:14 +00001628 return Expr;
1629}
1630
Argyrios Kyrtzidis7bbb20e2008-06-24 22:12:16 +00001631/// ParseCXXThis - This handles the C++ 'this' pointer.
1632///
1633/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1634/// a non-lvalue expression whose value is the address of the object for which
1635/// the function is called.
John McCalldadc5752010-08-24 06:29:42 +00001636ExprResult Parser::ParseCXXThis() {
Argyrios Kyrtzidis7bbb20e2008-06-24 22:12:16 +00001637 assert(Tok.is(tok::kw_this) && "Not 'this'!");
1638 SourceLocation ThisLoc = ConsumeToken();
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001639 return Actions.ActOnCXXThis(ThisLoc);
Argyrios Kyrtzidis7bbb20e2008-06-24 22:12:16 +00001640}
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001641
1642/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1643/// Can be interpreted either as function-style casting ("int(x)")
1644/// or class type construction ("ClassType(x,y,z)")
1645/// or creation of a value-initialized type ("int()").
Sebastian Redl3da34892011-06-05 12:23:16 +00001646/// See [C++ 5.2.3].
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001647///
1648/// postfix-expression: [C++ 5.2p1]
Sebastian Redl3da34892011-06-05 12:23:16 +00001649/// simple-type-specifier '(' expression-list[opt] ')'
1650/// [C++0x] simple-type-specifier braced-init-list
1651/// typename-specifier '(' expression-list[opt] ')'
1652/// [C++0x] typename-specifier braced-init-list
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001653///
Richard Smith600b5262017-01-26 20:40:47 +00001654/// In C++1z onwards, the type specifier can also be a template-name.
John McCalldadc5752010-08-24 06:29:42 +00001655ExprResult
Sebastian Redld65cea82008-12-11 22:51:44 +00001656Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
Richard Smith600b5262017-01-26 20:40:47 +00001657 Declarator DeclaratorInfo(DS, Declarator::FunctionalCastContext);
John McCallba7bf592010-08-24 05:47:05 +00001658 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001659
Sebastian Redl3da34892011-06-05 12:23:16 +00001660 assert((Tok.is(tok::l_paren) ||
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001661 (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
Sebastian Redl3da34892011-06-05 12:23:16 +00001662 && "Expected '(' or '{'!");
Douglas Gregor94a32472011-01-11 00:33:19 +00001663
Sebastian Redl3da34892011-06-05 12:23:16 +00001664 if (Tok.is(tok::l_brace)) {
Sebastian Redld74dd492012-02-12 18:41:05 +00001665 ExprResult Init = ParseBraceInitializer();
1666 if (Init.isInvalid())
1667 return Init;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001668 Expr *InitList = Init.get();
Sebastian Redld74dd492012-02-12 18:41:05 +00001669 return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(),
1670 MultiExprArg(&InitList, 1),
1671 SourceLocation());
Sebastian Redl3da34892011-06-05 12:23:16 +00001672 } else {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001673 BalancedDelimiterTracker T(*this, tok::l_paren);
1674 T.consumeOpen();
Sebastian Redl3da34892011-06-05 12:23:16 +00001675
Benjamin Kramerf0623432012-08-23 22:51:59 +00001676 ExprVector Exprs;
Sebastian Redl3da34892011-06-05 12:23:16 +00001677 CommaLocsTy CommaLocs;
1678
1679 if (Tok.isNot(tok::r_paren)) {
Francisco Lopes da Silva975a9f62015-01-21 16:24:11 +00001680 if (ParseExpressionList(Exprs, CommaLocs, [&] {
1681 Actions.CodeCompleteConstructor(getCurScope(),
1682 TypeRep.get()->getCanonicalTypeInternal(),
1683 DS.getLocEnd(), Exprs);
1684 })) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00001685 SkipUntil(tok::r_paren, StopAtSemi);
Sebastian Redl3da34892011-06-05 12:23:16 +00001686 return ExprError();
1687 }
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001688 }
Sebastian Redl3da34892011-06-05 12:23:16 +00001689
1690 // Match the ')'.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001691 T.consumeClose();
Sebastian Redl3da34892011-06-05 12:23:16 +00001692
1693 // TypeRep could be null, if it references an invalid typedef.
1694 if (!TypeRep)
1695 return ExprError();
1696
1697 assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1698 "Unexpected number of commas!");
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001699 return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
Benjamin Kramer62b95d82012-08-23 21:35:17 +00001700 Exprs,
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00001701 T.getCloseLocation());
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001702 }
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001703}
1704
Douglas Gregor7bab5ff2009-11-25 00:27:52 +00001705/// ParseCXXCondition - if/switch/while condition expression.
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001706///
1707/// condition:
1708/// expression
1709/// type-specifier-seq declarator '=' assignment-expression
Richard Smith2a15b742012-02-22 06:49:09 +00001710/// [C++11] type-specifier-seq declarator '=' initializer-clause
1711/// [C++11] type-specifier-seq declarator braced-init-list
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001712/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1713/// '=' assignment-expression
1714///
Richard Smithc7a05a92016-06-29 21:17:59 +00001715/// In C++1z, a condition may in some contexts be preceded by an
1716/// optional init-statement. This function will parse that too.
1717///
1718/// \param InitStmt If non-null, an init-statement is permitted, and if present
1719/// will be parsed and stored here.
1720///
Douglas Gregore60e41a2010-05-06 17:25:47 +00001721/// \param Loc The location of the start of the statement that requires this
1722/// condition, e.g., the "for" in a for loop.
1723///
Richard Smith03a4aa32016-06-23 19:02:52 +00001724/// \returns The parsed condition.
Richard Smithc7a05a92016-06-29 21:17:59 +00001725Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
1726 SourceLocation Loc,
Richard Smith03a4aa32016-06-23 19:02:52 +00001727 Sema::ConditionKind CK) {
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001728 if (Tok.is(tok::code_completion)) {
John McCallfaf5fb42010-08-26 23:41:50 +00001729 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
Argyrios Kyrtzidis5cec2ae2011-09-04 03:32:15 +00001730 cutOffParsing();
Richard Smith03a4aa32016-06-23 19:02:52 +00001731 return Sema::ConditionError();
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001732 }
1733
Alexis Hunt6aa9bee2012-06-23 05:07:58 +00001734 ParsedAttributesWithRange attrs(AttrFactory);
Richard Smith89645bc2013-01-02 12:01:23 +00001735 MaybeParseCXX11Attributes(attrs);
Alexis Hunt6aa9bee2012-06-23 05:07:58 +00001736
Richard Smithc7a05a92016-06-29 21:17:59 +00001737 // Determine what kind of thing we have.
1738 switch (isCXXConditionDeclarationOrInitStatement(InitStmt)) {
1739 case ConditionOrInitStatement::Expression: {
Alexis Hunt6aa9bee2012-06-23 05:07:58 +00001740 ProhibitAttributes(attrs);
1741
Douglas Gregore60e41a2010-05-06 17:25:47 +00001742 // Parse the expression.
Richard Smith03a4aa32016-06-23 19:02:52 +00001743 ExprResult Expr = ParseExpression(); // expression
1744 if (Expr.isInvalid())
1745 return Sema::ConditionError();
Douglas Gregore60e41a2010-05-06 17:25:47 +00001746
Richard Smithc7a05a92016-06-29 21:17:59 +00001747 if (InitStmt && Tok.is(tok::semi)) {
1748 *InitStmt = Actions.ActOnExprStmt(Expr.get());
1749 ConsumeToken();
1750 return ParseCXXCondition(nullptr, Loc, CK);
1751 }
1752
Richard Smith03a4aa32016-06-23 19:02:52 +00001753 return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK);
Douglas Gregor7bab5ff2009-11-25 00:27:52 +00001754 }
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001755
Richard Smithc7a05a92016-06-29 21:17:59 +00001756 case ConditionOrInitStatement::InitStmtDecl: {
Richard Smithfccb5122016-10-18 20:27:16 +00001757 Diag(Tok.getLocation(), getLangOpts().CPlusPlus1z
1758 ? diag::warn_cxx14_compat_init_statement
1759 : diag::ext_init_statement)
1760 << (CK == Sema::ConditionKind::Switch);
Richard Smithc7a05a92016-06-29 21:17:59 +00001761 SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1762 DeclGroupPtrTy DG = ParseSimpleDeclaration(
1763 Declarator::InitStmtContext, DeclEnd, attrs, /*RequireSemi=*/true);
1764 *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
1765 return ParseCXXCondition(nullptr, Loc, CK);
1766 }
1767
1768 case ConditionOrInitStatement::ConditionDecl:
1769 case ConditionOrInitStatement::Error:
1770 break;
1771 }
1772
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001773 // type-specifier-seq
John McCall084e83d2011-03-24 11:26:52 +00001774 DeclSpec DS(AttrFactory);
Richard Smith54ecd982013-02-20 19:22:51 +00001775 DS.takeAttributesFrom(attrs);
Meador Ingef0af05c2015-06-25 22:06:40 +00001776 ParseSpecifierQualifierList(DS, AS_none, DSC_condition);
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001777
1778 // declarator
1779 Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
1780 ParseDeclarator(DeclaratorInfo);
1781
1782 // simple-asm-expr[opt]
1783 if (Tok.is(tok::kw_asm)) {
Sebastian Redlf6591ca2009-02-09 18:23:29 +00001784 SourceLocation Loc;
John McCalldadc5752010-08-24 06:29:42 +00001785 ExprResult AsmLabel(ParseSimpleAsm(&Loc));
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001786 if (AsmLabel.isInvalid()) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00001787 SkipUntil(tok::semi, StopAtSemi);
Richard Smith03a4aa32016-06-23 19:02:52 +00001788 return Sema::ConditionError();
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001789 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001790 DeclaratorInfo.setAsmLabel(AsmLabel.get());
Sebastian Redlf6591ca2009-02-09 18:23:29 +00001791 DeclaratorInfo.SetRangeEnd(Loc);
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001792 }
1793
1794 // If attributes are present, parse them.
John McCall53fa7142010-12-24 02:08:15 +00001795 MaybeParseGNUAttributes(DeclaratorInfo);
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001796
Douglas Gregor7bab5ff2009-11-25 00:27:52 +00001797 // Type-check the declaration itself.
John McCalldadc5752010-08-24 06:29:42 +00001798 DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
John McCall53fa7142010-12-24 02:08:15 +00001799 DeclaratorInfo);
Richard Smith03a4aa32016-06-23 19:02:52 +00001800 if (Dcl.isInvalid())
1801 return Sema::ConditionError();
1802 Decl *DeclOut = Dcl.get();
Argyrios Kyrtzidisb5c7c512010-10-08 02:39:23 +00001803
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001804 // '=' assignment-expression
Richard Trieuc64d3232012-01-18 22:54:52 +00001805 // If a '==' or '+=' is found, suggest a fixit to '='.
Richard Smith2a15b742012-02-22 06:49:09 +00001806 bool CopyInitialization = isTokenEqualOrEqualTypo();
1807 if (CopyInitialization)
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +00001808 ConsumeToken();
Richard Smith2a15b742012-02-22 06:49:09 +00001809
1810 ExprResult InitExpr = ExprError();
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001811 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
Richard Smith2a15b742012-02-22 06:49:09 +00001812 Diag(Tok.getLocation(),
1813 diag::warn_cxx98_compat_generalized_initializer_lists);
1814 InitExpr = ParseBraceInitializer();
1815 } else if (CopyInitialization) {
1816 InitExpr = ParseAssignmentExpression();
1817 } else if (Tok.is(tok::l_paren)) {
1818 // This was probably an attempt to initialize the variable.
1819 SourceLocation LParen = ConsumeParen(), RParen = LParen;
Alexey Bataevee6507d2013-11-18 08:17:37 +00001820 if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
Richard Smith2a15b742012-02-22 06:49:09 +00001821 RParen = ConsumeParen();
Richard Smith03a4aa32016-06-23 19:02:52 +00001822 Diag(DeclOut->getLocation(),
Richard Smith2a15b742012-02-22 06:49:09 +00001823 diag::err_expected_init_in_condition_lparen)
1824 << SourceRange(LParen, RParen);
Douglas Gregor7bab5ff2009-11-25 00:27:52 +00001825 } else {
Richard Smith03a4aa32016-06-23 19:02:52 +00001826 Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
Douglas Gregor7bab5ff2009-11-25 00:27:52 +00001827 }
Richard Smith2a15b742012-02-22 06:49:09 +00001828
1829 if (!InitExpr.isInvalid())
Richard Smith3beb7c62017-01-12 02:27:38 +00001830 Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
Richard Smith27d807c2013-04-30 13:56:41 +00001831 else
1832 Actions.ActOnInitializerError(DeclOut);
Richard Smith2a15b742012-02-22 06:49:09 +00001833
Richard Smithb2bc2e62011-02-21 20:05:19 +00001834 Actions.FinalizeDeclaration(DeclOut);
Richard Smith03a4aa32016-06-23 19:02:52 +00001835 return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
Argyrios Kyrtzidis2b4072f2008-09-09 20:38:47 +00001836}
1837
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001838/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1839/// This should only be called when the current token is known to be part of
1840/// simple-type-specifier.
1841///
1842/// simple-type-specifier:
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +00001843/// '::'[opt] nested-name-specifier[opt] type-name
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001844/// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1845/// char
1846/// wchar_t
1847/// bool
1848/// short
1849/// int
1850/// long
1851/// signed
1852/// unsigned
1853/// float
1854/// double
1855/// void
1856/// [GNU] typeof-specifier
1857/// [C++0x] auto [TODO]
1858///
1859/// type-name:
1860/// class-name
1861/// enum-name
1862/// typedef-name
1863///
1864void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
1865 DS.SetRangeStart(Tok.getLocation());
1866 const char *PrevSpec;
John McCall49bfce42009-08-03 20:12:06 +00001867 unsigned DiagID;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001868 SourceLocation Loc = Tok.getLocation();
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001869 const clang::PrintingPolicy &Policy =
1870 Actions.getASTContext().getPrintingPolicy();
Mike Stump11289f42009-09-09 15:08:12 +00001871
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001872 switch (Tok.getKind()) {
Chris Lattner45ddec32009-01-05 00:13:00 +00001873 case tok::identifier: // foo::bar
1874 case tok::coloncolon: // ::foo::bar
David Blaikie83d382b2011-09-23 05:06:16 +00001875 llvm_unreachable("Annotation token should already be formed!");
Mike Stump11289f42009-09-09 15:08:12 +00001876 default:
David Blaikie83d382b2011-09-23 05:06:16 +00001877 llvm_unreachable("Not a simple-type-specifier token!");
Chris Lattner45ddec32009-01-05 00:13:00 +00001878
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001879 // type-name
Chris Lattnera8a3f732009-01-06 05:06:21 +00001880 case tok::annot_typename: {
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001881 if (getTypeAnnotation(Tok))
1882 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001883 getTypeAnnotation(Tok), Policy);
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001884 else
1885 DS.SetTypeSpecError();
Douglas Gregor06e41ae2010-10-21 23:17:00 +00001886
1887 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
Richard Smithaf3b3252017-05-18 19:21:48 +00001888 ConsumeAnnotationToken();
Douglas Gregor06e41ae2010-10-21 23:17:00 +00001889
Craig Topper25122412015-11-15 03:32:11 +00001890 DS.Finish(Actions, Policy);
Douglas Gregor06e41ae2010-10-21 23:17:00 +00001891 return;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001892 }
Mike Stump11289f42009-09-09 15:08:12 +00001893
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001894 // builtin types
1895 case tok::kw_short:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001896 DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001897 break;
1898 case tok::kw_long:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001899 DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001900 break;
Francois Pichet84133e42011-04-28 01:59:37 +00001901 case tok::kw___int64:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001902 DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy);
Francois Pichet84133e42011-04-28 01:59:37 +00001903 break;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001904 case tok::kw_signed:
John McCall49bfce42009-08-03 20:12:06 +00001905 DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001906 break;
1907 case tok::kw_unsigned:
John McCall49bfce42009-08-03 20:12:06 +00001908 DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001909 break;
1910 case tok::kw_void:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001911 DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001912 break;
1913 case tok::kw_char:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001914 DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001915 break;
1916 case tok::kw_int:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001917 DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001918 break;
Richard Smithf016bbc2012-04-04 06:24:32 +00001919 case tok::kw___int128:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001920 DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
Richard Smithf016bbc2012-04-04 06:24:32 +00001921 break;
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00001922 case tok::kw_half:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001923 DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00001924 break;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001925 case tok::kw_float:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001926 DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001927 break;
1928 case tok::kw_double:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001929 DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001930 break;
Sjoerd Meijercc623ad2017-09-08 15:15:00 +00001931 case tok::kw__Float16:
1932 DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
1933 break;
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +00001934 case tok::kw___float128:
1935 DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
1936 break;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001937 case tok::kw_wchar_t:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001938 DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001939 break;
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001940 case tok::kw_char16_t:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001941 DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001942 break;
1943 case tok::kw_char32_t:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001944 DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001945 break;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001946 case tok::kw_bool:
Erik Verbruggen888d52a2014-01-15 09:15:43 +00001947 DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001948 break;
David Blaikie25896afb2012-01-24 05:47:35 +00001949 case tok::annot_decltype:
1950 case tok::kw_decltype:
1951 DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
Craig Topper25122412015-11-15 03:32:11 +00001952 return DS.Finish(Actions, Policy);
Mike Stump11289f42009-09-09 15:08:12 +00001953
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001954 // GNU typeof support.
1955 case tok::kw_typeof:
1956 ParseTypeofSpecifier(DS);
Craig Topper25122412015-11-15 03:32:11 +00001957 DS.Finish(Actions, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001958 return;
1959 }
Richard Smithaf3b3252017-05-18 19:21:48 +00001960 ConsumeAnyToken();
1961 DS.SetRangeEnd(PrevTokLocation);
Craig Topper25122412015-11-15 03:32:11 +00001962 DS.Finish(Actions, Policy);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001963}
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00001964
Douglas Gregordbc5daf2008-11-07 20:08:42 +00001965/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1966/// [dcl.name]), which is a non-empty sequence of type-specifiers,
1967/// e.g., "const short int". Note that the DeclSpec is *not* finished
1968/// by parsing the type-specifier-seq, because these sequences are
1969/// typically followed by some form of declarator. Returns true and
1970/// emits diagnostics if this is not a type-specifier-seq, false
1971/// otherwise.
1972///
1973/// type-specifier-seq: [C++ 8.1]
1974/// type-specifier type-specifier-seq[opt]
1975///
1976bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
Richard Smithc5b05522012-03-12 07:56:15 +00001977 ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
Craig Topper25122412015-11-15 03:32:11 +00001978 DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
Douglas Gregordbc5daf2008-11-07 20:08:42 +00001979 return false;
1980}
1981
Douglas Gregor7861a802009-11-03 01:35:08 +00001982/// \brief Finish parsing a C++ unqualified-id that is a template-id of
1983/// some form.
1984///
1985/// This routine is invoked when a '<' is encountered after an identifier or
1986/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1987/// whether the unqualified-id is actually a template-id. This routine will
1988/// then parse the template arguments and form the appropriate template-id to
1989/// return to the caller.
1990///
1991/// \param SS the nested-name-specifier that precedes this template-id, if
1992/// we're actually parsing a qualified-id.
1993///
1994/// \param Name for constructor and destructor names, this is the actual
1995/// identifier that may be a template-name.
1996///
1997/// \param NameLoc the location of the class-name in a constructor or
1998/// destructor.
1999///
2000/// \param EnteringContext whether we're entering the scope of the
2001/// nested-name-specifier.
2002///
Douglas Gregor127ea592009-11-03 21:24:04 +00002003/// \param ObjectType if this unqualified-id occurs within a member access
2004/// expression, the type of the base object whose member is being accessed.
2005///
Douglas Gregor7861a802009-11-03 01:35:08 +00002006/// \param Id as input, describes the template-name or operator-function-id
2007/// that precedes the '<'. If template arguments were parsed successfully,
2008/// will be updated with the template-id.
2009///
Douglas Gregore610ada2010-02-24 18:44:31 +00002010/// \param AssumeTemplateId When true, this routine will assume that the name
2011/// refers to a template without performing name lookup to verify.
2012///
Douglas Gregor7861a802009-11-03 01:35:08 +00002013/// \returns true if a parse error occurred, false otherwise.
2014bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +00002015 SourceLocation TemplateKWLoc,
Douglas Gregor7861a802009-11-03 01:35:08 +00002016 IdentifierInfo *Name,
2017 SourceLocation NameLoc,
2018 bool EnteringContext,
John McCallba7bf592010-08-24 05:47:05 +00002019 ParsedType ObjectType,
Douglas Gregore610ada2010-02-24 18:44:31 +00002020 UnqualifiedId &Id,
Abramo Bagnara7945c982012-01-27 09:46:47 +00002021 bool AssumeTemplateId) {
Douglas Gregorb22ee882010-05-05 05:58:24 +00002022 assert((AssumeTemplateId || Tok.is(tok::less)) &&
2023 "Expected '<' to finish parsing a template-id");
Douglas Gregor7861a802009-11-03 01:35:08 +00002024
2025 TemplateTy Template;
2026 TemplateNameKind TNK = TNK_Non_template;
2027 switch (Id.getKind()) {
2028 case UnqualifiedId::IK_Identifier:
Douglas Gregor3cf81312009-11-03 23:16:33 +00002029 case UnqualifiedId::IK_OperatorFunctionId:
Alexis Hunted0530f2009-11-28 08:58:14 +00002030 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregore610ada2010-02-24 18:44:31 +00002031 if (AssumeTemplateId) {
Richard Smithfd3dae02017-01-20 00:20:39 +00002032 // We defer the injected-class-name checks until we've found whether
2033 // this template-id is used to form a nested-name-specifier or not.
2034 TNK = Actions.ActOnDependentTemplateName(
2035 getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2036 Template, /*AllowInjectedClassName*/ true);
Douglas Gregorbb119652010-06-16 23:00:59 +00002037 if (TNK == TNK_Non_template)
2038 return true;
Douglas Gregor786123d2010-05-21 23:18:07 +00002039 } else {
2040 bool MemberOfUnknownSpecialization;
Abramo Bagnara7c5dee42010-08-06 12:11:11 +00002041 TNK = Actions.isTemplateName(getCurScope(), SS,
2042 TemplateKWLoc.isValid(), Id,
2043 ObjectType, EnteringContext, Template,
Douglas Gregor786123d2010-05-21 23:18:07 +00002044 MemberOfUnknownSpecialization);
2045
2046 if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
2047 ObjectType && IsTemplateArgumentList()) {
2048 // We have something like t->getAs<T>(), where getAs is a
2049 // member of an unknown specialization. However, this will only
2050 // parse correctly as a template, so suggest the keyword 'template'
2051 // before 'getAs' and treat this as a dependent template name.
2052 std::string Name;
2053 if (Id.getKind() == UnqualifiedId::IK_Identifier)
2054 Name = Id.Identifier->getName();
2055 else {
2056 Name = "operator ";
2057 if (Id.getKind() == UnqualifiedId::IK_OperatorFunctionId)
2058 Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
2059 else
2060 Name += Id.Identifier->getName();
2061 }
2062 Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
2063 << Name
2064 << FixItHint::CreateInsertion(Id.StartLocation, "template ");
Richard Smithfd3dae02017-01-20 00:20:39 +00002065 TNK = Actions.ActOnDependentTemplateName(
2066 getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2067 Template, /*AllowInjectedClassName*/ true);
Douglas Gregorbb119652010-06-16 23:00:59 +00002068 if (TNK == TNK_Non_template)
Douglas Gregor786123d2010-05-21 23:18:07 +00002069 return true;
2070 }
2071 }
Douglas Gregor7861a802009-11-03 01:35:08 +00002072 break;
2073
Douglas Gregor3cf81312009-11-03 23:16:33 +00002074 case UnqualifiedId::IK_ConstructorName: {
2075 UnqualifiedId TemplateName;
Douglas Gregor786123d2010-05-21 23:18:07 +00002076 bool MemberOfUnknownSpecialization;
Douglas Gregor3cf81312009-11-03 23:16:33 +00002077 TemplateName.setIdentifier(Name, NameLoc);
Abramo Bagnara7c5dee42010-08-06 12:11:11 +00002078 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2079 TemplateName, ObjectType,
Douglas Gregor786123d2010-05-21 23:18:07 +00002080 EnteringContext, Template,
2081 MemberOfUnknownSpecialization);
Douglas Gregor7861a802009-11-03 01:35:08 +00002082 break;
2083 }
2084
Douglas Gregor3cf81312009-11-03 23:16:33 +00002085 case UnqualifiedId::IK_DestructorName: {
2086 UnqualifiedId TemplateName;
Douglas Gregor786123d2010-05-21 23:18:07 +00002087 bool MemberOfUnknownSpecialization;
Douglas Gregor3cf81312009-11-03 23:16:33 +00002088 TemplateName.setIdentifier(Name, NameLoc);
Douglas Gregor30d60cb2009-11-03 19:44:04 +00002089 if (ObjectType) {
Richard Smithfd3dae02017-01-20 00:20:39 +00002090 TNK = Actions.ActOnDependentTemplateName(
2091 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2092 EnteringContext, Template, /*AllowInjectedClassName*/ true);
Douglas Gregorbb119652010-06-16 23:00:59 +00002093 if (TNK == TNK_Non_template)
Douglas Gregor30d60cb2009-11-03 19:44:04 +00002094 return true;
2095 } else {
Abramo Bagnara7c5dee42010-08-06 12:11:11 +00002096 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2097 TemplateName, ObjectType,
Douglas Gregor786123d2010-05-21 23:18:07 +00002098 EnteringContext, Template,
2099 MemberOfUnknownSpecialization);
Douglas Gregor30d60cb2009-11-03 19:44:04 +00002100
John McCallba7bf592010-08-24 05:47:05 +00002101 if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
Douglas Gregorfe17d252010-02-16 19:09:40 +00002102 Diag(NameLoc, diag::err_destructor_template_id)
2103 << Name << SS.getRange();
Douglas Gregor30d60cb2009-11-03 19:44:04 +00002104 return true;
2105 }
2106 }
Douglas Gregor7861a802009-11-03 01:35:08 +00002107 break;
Douglas Gregor3cf81312009-11-03 23:16:33 +00002108 }
Douglas Gregor7861a802009-11-03 01:35:08 +00002109
2110 default:
2111 return false;
2112 }
2113
2114 if (TNK == TNK_Non_template)
2115 return false;
2116
2117 // Parse the enclosed template argument list.
2118 SourceLocation LAngleLoc, RAngleLoc;
2119 TemplateArgList TemplateArgs;
Richard Smith9a420f92017-05-10 21:47:30 +00002120 if (Tok.is(tok::less) && ParseTemplateIdAfterTemplateName(
2121 true, LAngleLoc, TemplateArgs, RAngleLoc))
Douglas Gregor7861a802009-11-03 01:35:08 +00002122 return true;
2123
2124 if (Id.getKind() == UnqualifiedId::IK_Identifier ||
Alexis Hunted0530f2009-11-28 08:58:14 +00002125 Id.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2126 Id.getKind() == UnqualifiedId::IK_LiteralOperatorId) {
Douglas Gregor7861a802009-11-03 01:35:08 +00002127 // Form a parsed representation of the template-id to be stored in the
2128 // UnqualifiedId.
Douglas Gregor7861a802009-11-03 01:35:08 +00002129
Richard Smith72bfbd82013-12-04 00:28:23 +00002130 // FIXME: Store name for literal operator too.
Faisal Vali43caf672017-05-23 01:07:12 +00002131 IdentifierInfo *TemplateII =
2132 Id.getKind() == UnqualifiedId::IK_Identifier ? Id.Identifier : nullptr;
2133 OverloadedOperatorKind OpKind = Id.getKind() == UnqualifiedId::IK_Identifier
2134 ? OO_None
2135 : Id.OperatorFunctionId.Operator;
Douglas Gregor7861a802009-11-03 01:35:08 +00002136
Faisal Vali43caf672017-05-23 01:07:12 +00002137 TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create(
2138 SS, TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
2139 LAngleLoc, RAngleLoc, TemplateArgs, TemplateIds);
2140
Douglas Gregor7861a802009-11-03 01:35:08 +00002141 Id.setTemplateId(TemplateId);
2142 return false;
2143 }
2144
2145 // Bundle the template arguments together.
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00002146 ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
Abramo Bagnara4244b432012-01-27 08:46:19 +00002147
Douglas Gregor7861a802009-11-03 01:35:08 +00002148 // Constructor and destructor names.
John McCallfaf5fb42010-08-26 23:41:50 +00002149 TypeResult Type
Abramo Bagnara48c05be2012-02-06 14:41:24 +00002150 = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
Richard Smith74f02342017-01-19 21:00:13 +00002151 Template, Name, NameLoc,
Abramo Bagnara4244b432012-01-27 08:46:19 +00002152 LAngleLoc, TemplateArgsPtr, RAngleLoc,
2153 /*IsCtorOrDtorName=*/true);
Douglas Gregor7861a802009-11-03 01:35:08 +00002154 if (Type.isInvalid())
2155 return true;
2156
2157 if (Id.getKind() == UnqualifiedId::IK_ConstructorName)
2158 Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2159 else
2160 Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2161
2162 return false;
2163}
2164
Douglas Gregor71395fa2009-11-04 00:56:37 +00002165/// \brief Parse an operator-function-id or conversion-function-id as part
2166/// of a C++ unqualified-id.
2167///
2168/// This routine is responsible only for parsing the operator-function-id or
2169/// conversion-function-id; it does not handle template arguments in any way.
Douglas Gregor7861a802009-11-03 01:35:08 +00002170///
2171/// \code
Douglas Gregor7861a802009-11-03 01:35:08 +00002172/// operator-function-id: [C++ 13.5]
2173/// 'operator' operator
2174///
Douglas Gregor71395fa2009-11-04 00:56:37 +00002175/// operator: one of
Douglas Gregor7861a802009-11-03 01:35:08 +00002176/// new delete new[] delete[]
2177/// + - * / % ^ & | ~
2178/// ! = < > += -= *= /= %=
2179/// ^= &= |= << >> >>= <<= == !=
2180/// <= >= && || ++ -- , ->* ->
2181/// () []
2182///
2183/// conversion-function-id: [C++ 12.3.2]
2184/// operator conversion-type-id
2185///
2186/// conversion-type-id:
2187/// type-specifier-seq conversion-declarator[opt]
2188///
2189/// conversion-declarator:
2190/// ptr-operator conversion-declarator[opt]
2191/// \endcode
2192///
Dmitri Gribenkodd28e792012-08-24 00:01:24 +00002193/// \param SS The nested-name-specifier that preceded this unqualified-id. If
Douglas Gregor7861a802009-11-03 01:35:08 +00002194/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2195///
2196/// \param EnteringContext whether we are entering the scope of the
2197/// nested-name-specifier.
2198///
Douglas Gregor71395fa2009-11-04 00:56:37 +00002199/// \param ObjectType if this unqualified-id occurs within a member access
2200/// expression, the type of the base object whose member is being accessed.
2201///
2202/// \param Result on a successful parse, contains the parsed unqualified-id.
2203///
2204/// \returns true if parsing fails, false otherwise.
2205bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
John McCallba7bf592010-08-24 05:47:05 +00002206 ParsedType ObjectType,
Douglas Gregor71395fa2009-11-04 00:56:37 +00002207 UnqualifiedId &Result) {
2208 assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
2209
2210 // Consume the 'operator' keyword.
2211 SourceLocation KeywordLoc = ConsumeToken();
2212
2213 // Determine what kind of operator name we have.
2214 unsigned SymbolIdx = 0;
2215 SourceLocation SymbolLocations[3];
2216 OverloadedOperatorKind Op = OO_None;
2217 switch (Tok.getKind()) {
2218 case tok::kw_new:
2219 case tok::kw_delete: {
2220 bool isNew = Tok.getKind() == tok::kw_new;
2221 // Consume the 'new' or 'delete'.
2222 SymbolLocations[SymbolIdx++] = ConsumeToken();
Richard Smith7bdcc4a2012-04-10 01:32:12 +00002223 // Check for array new/delete.
2224 if (Tok.is(tok::l_square) &&
Richard Smith2bf7fdb2013-01-02 11:42:31 +00002225 (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002226 // Consume the '[' and ']'.
2227 BalancedDelimiterTracker T(*this, tok::l_square);
2228 T.consumeOpen();
2229 T.consumeClose();
2230 if (T.getCloseLocation().isInvalid())
Douglas Gregor71395fa2009-11-04 00:56:37 +00002231 return true;
2232
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002233 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2234 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
Douglas Gregor71395fa2009-11-04 00:56:37 +00002235 Op = isNew? OO_Array_New : OO_Array_Delete;
2236 } else {
2237 Op = isNew? OO_New : OO_Delete;
2238 }
2239 break;
2240 }
2241
2242#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2243 case tok::Token: \
2244 SymbolLocations[SymbolIdx++] = ConsumeToken(); \
2245 Op = OO_##Name; \
2246 break;
2247#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2248#include "clang/Basic/OperatorKinds.def"
2249
2250 case tok::l_paren: {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002251 // Consume the '(' and ')'.
2252 BalancedDelimiterTracker T(*this, tok::l_paren);
2253 T.consumeOpen();
2254 T.consumeClose();
2255 if (T.getCloseLocation().isInvalid())
Douglas Gregor71395fa2009-11-04 00:56:37 +00002256 return true;
2257
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002258 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2259 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
Douglas Gregor71395fa2009-11-04 00:56:37 +00002260 Op = OO_Call;
2261 break;
2262 }
2263
2264 case tok::l_square: {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002265 // Consume the '[' and ']'.
2266 BalancedDelimiterTracker T(*this, tok::l_square);
2267 T.consumeOpen();
2268 T.consumeClose();
2269 if (T.getCloseLocation().isInvalid())
Douglas Gregor71395fa2009-11-04 00:56:37 +00002270 return true;
2271
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002272 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2273 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
Douglas Gregor71395fa2009-11-04 00:56:37 +00002274 Op = OO_Subscript;
2275 break;
2276 }
2277
2278 case tok::code_completion: {
2279 // Code completion for the operator name.
Douglas Gregor0be31a22010-07-02 17:43:08 +00002280 Actions.CodeCompleteOperatorName(getCurScope());
Argyrios Kyrtzidis5cec2ae2011-09-04 03:32:15 +00002281 cutOffParsing();
Douglas Gregor71395fa2009-11-04 00:56:37 +00002282 // Don't try to parse any further.
2283 return true;
2284 }
2285
2286 default:
2287 break;
2288 }
2289
2290 if (Op != OO_None) {
2291 // We have parsed an operator-function-id.
2292 Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2293 return false;
2294 }
Alexis Hunt34458502009-11-28 04:44:28 +00002295
2296 // Parse a literal-operator-id.
2297 //
Richard Smith6f212062012-10-20 08:41:10 +00002298 // literal-operator-id: C++11 [over.literal]
2299 // operator string-literal identifier
2300 // operator user-defined-string-literal
Alexis Hunt34458502009-11-28 04:44:28 +00002301
Richard Smith2bf7fdb2013-01-02 11:42:31 +00002302 if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
Richard Smith5d164bc2011-10-15 05:09:34 +00002303 Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
Alexis Hunt34458502009-11-28 04:44:28 +00002304
Richard Smith7d182a72012-03-08 23:06:02 +00002305 SourceLocation DiagLoc;
2306 unsigned DiagId = 0;
2307
2308 // We're past translation phase 6, so perform string literal concatenation
2309 // before checking for "".
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002310 SmallVector<Token, 4> Toks;
2311 SmallVector<SourceLocation, 4> TokLocs;
Richard Smith7d182a72012-03-08 23:06:02 +00002312 while (isTokenStringLiteral()) {
2313 if (!Tok.is(tok::string_literal) && !DiagId) {
Richard Smith6f212062012-10-20 08:41:10 +00002314 // C++11 [over.literal]p1:
2315 // The string-literal or user-defined-string-literal in a
2316 // literal-operator-id shall have no encoding-prefix [...].
Richard Smith7d182a72012-03-08 23:06:02 +00002317 DiagLoc = Tok.getLocation();
2318 DiagId = diag::err_literal_operator_string_prefix;
2319 }
2320 Toks.push_back(Tok);
2321 TokLocs.push_back(ConsumeStringToken());
2322 }
2323
Craig Topper9d5583e2014-06-26 04:58:39 +00002324 StringLiteralParser Literal(Toks, PP);
Richard Smith7d182a72012-03-08 23:06:02 +00002325 if (Literal.hadError)
2326 return true;
2327
2328 // Grab the literal operator's suffix, which will be either the next token
2329 // or a ud-suffix from the string literal.
Craig Topper161e4db2014-05-21 06:02:52 +00002330 IdentifierInfo *II = nullptr;
Richard Smith7d182a72012-03-08 23:06:02 +00002331 SourceLocation SuffixLoc;
2332 if (!Literal.getUDSuffix().empty()) {
2333 II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2334 SuffixLoc =
2335 Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
2336 Literal.getUDSuffixOffset(),
David Blaikiebbafb8a2012-03-11 07:00:24 +00002337 PP.getSourceManager(), getLangOpts());
Richard Smith7d182a72012-03-08 23:06:02 +00002338 } else if (Tok.is(tok::identifier)) {
2339 II = Tok.getIdentifierInfo();
2340 SuffixLoc = ConsumeToken();
2341 TokLocs.push_back(SuffixLoc);
2342 } else {
Alp Tokerec543272013-12-24 09:48:30 +00002343 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
Alexis Hunt34458502009-11-28 04:44:28 +00002344 return true;
2345 }
2346
Richard Smith7d182a72012-03-08 23:06:02 +00002347 // The string literal must be empty.
2348 if (!Literal.GetString().empty() || Literal.Pascal) {
Richard Smith6f212062012-10-20 08:41:10 +00002349 // C++11 [over.literal]p1:
2350 // The string-literal or user-defined-string-literal in a
2351 // literal-operator-id shall [...] contain no characters
2352 // other than the implicit terminating '\0'.
Richard Smith7d182a72012-03-08 23:06:02 +00002353 DiagLoc = TokLocs.front();
2354 DiagId = diag::err_literal_operator_string_not_empty;
2355 }
2356
2357 if (DiagId) {
2358 // This isn't a valid literal-operator-id, but we think we know
2359 // what the user meant. Tell them what they should have written.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002360 SmallString<32> Str;
Richard Smithe87aeb32015-10-08 00:17:59 +00002361 Str += "\"\"";
Richard Smith7d182a72012-03-08 23:06:02 +00002362 Str += II->getName();
2363 Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2364 SourceRange(TokLocs.front(), TokLocs.back()), Str);
2365 }
2366
2367 Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
Richard Smithd091dc12013-12-05 00:58:33 +00002368
2369 return Actions.checkLiteralOperatorId(SS, Result);
Alexis Hunt34458502009-11-28 04:44:28 +00002370 }
Richard Smithd091dc12013-12-05 00:58:33 +00002371
Douglas Gregor71395fa2009-11-04 00:56:37 +00002372 // Parse a conversion-function-id.
2373 //
2374 // conversion-function-id: [C++ 12.3.2]
2375 // operator conversion-type-id
2376 //
2377 // conversion-type-id:
2378 // type-specifier-seq conversion-declarator[opt]
2379 //
2380 // conversion-declarator:
2381 // ptr-operator conversion-declarator[opt]
2382
2383 // Parse the type-specifier-seq.
John McCall084e83d2011-03-24 11:26:52 +00002384 DeclSpec DS(AttrFactory);
Douglas Gregora25d65d2009-11-20 22:03:38 +00002385 if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
Douglas Gregor71395fa2009-11-04 00:56:37 +00002386 return true;
2387
2388 // Parse the conversion-declarator, which is merely a sequence of
2389 // ptr-operators.
Richard Smith01518fa2013-05-04 01:26:46 +00002390 Declarator D(DS, Declarator::ConversionIdContext);
Craig Topper161e4db2014-05-21 06:02:52 +00002391 ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2392
Douglas Gregor71395fa2009-11-04 00:56:37 +00002393 // Finish up the type.
John McCallfaf5fb42010-08-26 23:41:50 +00002394 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
Douglas Gregor71395fa2009-11-04 00:56:37 +00002395 if (Ty.isInvalid())
2396 return true;
2397
2398 // Note that this is a conversion-function-id.
2399 Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2400 D.getSourceRange().getEnd());
2401 return false;
2402}
2403
2404/// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
2405/// name of an entity.
2406///
2407/// \code
2408/// unqualified-id: [C++ expr.prim.general]
2409/// identifier
2410/// operator-function-id
2411/// conversion-function-id
2412/// [C++0x] literal-operator-id [TODO]
2413/// ~ class-name
2414/// template-id
2415///
2416/// \endcode
2417///
Dmitri Gribenkodd28e792012-08-24 00:01:24 +00002418/// \param SS The nested-name-specifier that preceded this unqualified-id. If
Douglas Gregor71395fa2009-11-04 00:56:37 +00002419/// non-empty, then we are parsing the unqualified-id of a qualified-id.
2420///
2421/// \param EnteringContext whether we are entering the scope of the
2422/// nested-name-specifier.
2423///
Douglas Gregor7861a802009-11-03 01:35:08 +00002424/// \param AllowDestructorName whether we allow parsing of a destructor name.
2425///
2426/// \param AllowConstructorName whether we allow parsing a constructor name.
2427///
Richard Smith35845152017-02-07 01:37:30 +00002428/// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2429///
Douglas Gregor127ea592009-11-03 21:24:04 +00002430/// \param ObjectType if this unqualified-id occurs within a member access
2431/// expression, the type of the base object whose member is being accessed.
2432///
Douglas Gregor7861a802009-11-03 01:35:08 +00002433/// \param Result on a successful parse, contains the parsed unqualified-id.
2434///
2435/// \returns true if parsing fails, false otherwise.
2436bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2437 bool AllowDestructorName,
2438 bool AllowConstructorName,
Richard Smith35845152017-02-07 01:37:30 +00002439 bool AllowDeductionGuide,
John McCallba7bf592010-08-24 05:47:05 +00002440 ParsedType ObjectType,
Abramo Bagnara7945c982012-01-27 09:46:47 +00002441 SourceLocation& TemplateKWLoc,
Douglas Gregor7861a802009-11-03 01:35:08 +00002442 UnqualifiedId &Result) {
Douglas Gregorb22ee882010-05-05 05:58:24 +00002443
2444 // Handle 'A::template B'. This is for template-ids which have not
2445 // already been annotated by ParseOptionalCXXScopeSpecifier().
2446 bool TemplateSpecified = false;
David Blaikiebbafb8a2012-03-11 07:00:24 +00002447 if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
Douglas Gregorb22ee882010-05-05 05:58:24 +00002448 (ObjectType || SS.isSet())) {
2449 TemplateSpecified = true;
2450 TemplateKWLoc = ConsumeToken();
2451 }
2452
Douglas Gregor7861a802009-11-03 01:35:08 +00002453 // unqualified-id:
2454 // identifier
2455 // template-id (when it hasn't already been annotated)
2456 if (Tok.is(tok::identifier)) {
2457 // Consume the identifier.
2458 IdentifierInfo *Id = Tok.getIdentifierInfo();
2459 SourceLocation IdLoc = ConsumeToken();
2460
David Blaikiebbafb8a2012-03-11 07:00:24 +00002461 if (!getLangOpts().CPlusPlus) {
Douglas Gregor411e5ac2010-01-11 23:29:10 +00002462 // If we're not in C++, only identifiers matter. Record the
2463 // identifier and return.
2464 Result.setIdentifier(Id, IdLoc);
2465 return false;
2466 }
2467
Richard Smith35845152017-02-07 01:37:30 +00002468 ParsedTemplateTy TemplateName;
Douglas Gregor7861a802009-11-03 01:35:08 +00002469 if (AllowConstructorName &&
Douglas Gregor0be31a22010-07-02 17:43:08 +00002470 Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
Douglas Gregor7861a802009-11-03 01:35:08 +00002471 // We have parsed a constructor name.
David Blaikieefdccaa2016-01-15 23:43:34 +00002472 ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, false,
2473 false, nullptr,
Abramo Bagnara4244b432012-01-27 08:46:19 +00002474 /*IsCtorOrDtorName=*/true,
2475 /*NonTrivialTypeSourceInfo=*/true);
2476 Result.setConstructorName(Ty, IdLoc, IdLoc);
Richard Smith35845152017-02-07 01:37:30 +00002477 } else if (getLangOpts().CPlusPlus1z &&
2478 AllowDeductionGuide && SS.isEmpty() &&
2479 Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
2480 &TemplateName)) {
2481 // We have parsed a template-name naming a deduction guide.
2482 Result.setDeductionGuideName(TemplateName, IdLoc);
Douglas Gregor7861a802009-11-03 01:35:08 +00002483 } else {
2484 // We have parsed an identifier.
2485 Result.setIdentifier(Id, IdLoc);
2486 }
2487
2488 // If the next token is a '<', we may have a template.
Douglas Gregorb22ee882010-05-05 05:58:24 +00002489 if (TemplateSpecified || Tok.is(tok::less))
Abramo Bagnara7945c982012-01-27 09:46:47 +00002490 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2491 EnteringContext, ObjectType,
2492 Result, TemplateSpecified);
Douglas Gregor7861a802009-11-03 01:35:08 +00002493
2494 return false;
2495 }
2496
2497 // unqualified-id:
2498 // template-id (already parsed and annotated)
2499 if (Tok.is(tok::annot_template_id)) {
Argyrios Kyrtzidisc0c5dd22011-06-22 06:09:49 +00002500 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002501
2502 // If the template-name names the current class, then this is a constructor
2503 if (AllowConstructorName && TemplateId->Name &&
Douglas Gregor0be31a22010-07-02 17:43:08 +00002504 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002505 if (SS.isSet()) {
2506 // C++ [class.qual]p2 specifies that a qualified template-name
2507 // is taken as the constructor name where a constructor can be
2508 // declared. Thus, the template arguments are extraneous, so
2509 // complain about them and remove them entirely.
2510 Diag(TemplateId->TemplateNameLoc,
2511 diag::err_out_of_line_constructor_template_id)
2512 << TemplateId->Name
Douglas Gregora771f462010-03-31 17:46:05 +00002513 << FixItHint::CreateRemoval(
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002514 SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
David Blaikieefdccaa2016-01-15 23:43:34 +00002515 ParsedType Ty =
2516 Actions.getTypeName(*TemplateId->Name, TemplateId->TemplateNameLoc,
2517 getCurScope(), &SS, false, false, nullptr,
2518 /*IsCtorOrDtorName=*/true,
2519 /*NontrivialTypeSourceInfo=*/true);
Abramo Bagnara4244b432012-01-27 08:46:19 +00002520 Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002521 TemplateId->RAngleLoc);
Richard Smithaf3b3252017-05-18 19:21:48 +00002522 ConsumeAnnotationToken();
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002523 return false;
2524 }
2525
2526 Result.setConstructorTemplateId(TemplateId);
Richard Smithaf3b3252017-05-18 19:21:48 +00002527 ConsumeAnnotationToken();
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002528 return false;
2529 }
2530
Douglas Gregor7861a802009-11-03 01:35:08 +00002531 // We have already parsed a template-id; consume the annotation token as
2532 // our unqualified-id.
Douglas Gregor9de54ea2010-01-13 17:31:36 +00002533 Result.setTemplateId(TemplateId);
Abramo Bagnara7945c982012-01-27 09:46:47 +00002534 TemplateKWLoc = TemplateId->TemplateKWLoc;
Richard Smithaf3b3252017-05-18 19:21:48 +00002535 ConsumeAnnotationToken();
Douglas Gregor7861a802009-11-03 01:35:08 +00002536 return false;
2537 }
2538
2539 // unqualified-id:
2540 // operator-function-id
2541 // conversion-function-id
2542 if (Tok.is(tok::kw_operator)) {
Douglas Gregor71395fa2009-11-04 00:56:37 +00002543 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
Douglas Gregor7861a802009-11-03 01:35:08 +00002544 return true;
2545
Alexis Hunted0530f2009-11-28 08:58:14 +00002546 // If we have an operator-function-id or a literal-operator-id and the next
2547 // token is a '<', we may have a
Douglas Gregor71395fa2009-11-04 00:56:37 +00002548 //
2549 // template-id:
2550 // operator-function-id < template-argument-list[opt] >
Alexis Hunted0530f2009-11-28 08:58:14 +00002551 if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2552 Result.getKind() == UnqualifiedId::IK_LiteralOperatorId) &&
Douglas Gregorb22ee882010-05-05 05:58:24 +00002553 (TemplateSpecified || Tok.is(tok::less)))
Abramo Bagnara7945c982012-01-27 09:46:47 +00002554 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
Craig Topper161e4db2014-05-21 06:02:52 +00002555 nullptr, SourceLocation(),
Abramo Bagnara7945c982012-01-27 09:46:47 +00002556 EnteringContext, ObjectType,
2557 Result, TemplateSpecified);
Craig Topper161e4db2014-05-21 06:02:52 +00002558
Douglas Gregor7861a802009-11-03 01:35:08 +00002559 return false;
2560 }
2561
David Blaikiebbafb8a2012-03-11 07:00:24 +00002562 if (getLangOpts().CPlusPlus &&
Douglas Gregor411e5ac2010-01-11 23:29:10 +00002563 (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
Douglas Gregor7861a802009-11-03 01:35:08 +00002564 // C++ [expr.unary.op]p10:
2565 // There is an ambiguity in the unary-expression ~X(), where X is a
2566 // class-name. The ambiguity is resolved in favor of treating ~ as a
2567 // unary complement rather than treating ~X as referring to a destructor.
2568
2569 // Parse the '~'.
2570 SourceLocation TildeLoc = ConsumeToken();
David Blaikieecd8a942011-12-08 16:13:53 +00002571
2572 if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2573 DeclSpec DS(AttrFactory);
2574 SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
Richard Smithef2cd8f2017-02-08 20:39:08 +00002575 if (ParsedType Type =
2576 Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
David Blaikieecd8a942011-12-08 16:13:53 +00002577 Result.setDestructorName(TildeLoc, Type, EndLoc);
2578 return false;
2579 }
2580 return true;
2581 }
Douglas Gregor7861a802009-11-03 01:35:08 +00002582
2583 // Parse the class-name.
2584 if (Tok.isNot(tok::identifier)) {
Douglas Gregorfe17d252010-02-16 19:09:40 +00002585 Diag(Tok, diag::err_destructor_tilde_identifier);
Douglas Gregor7861a802009-11-03 01:35:08 +00002586 return true;
2587 }
2588
Richard Smithefa6f732014-09-06 02:06:12 +00002589 // If the user wrote ~T::T, correct it to T::~T.
Richard Smith64e033f2015-01-15 00:48:52 +00002590 DeclaratorScopeObj DeclScopeObj(*this, SS);
Nico Weber10d02b52015-02-02 04:18:38 +00002591 if (!TemplateSpecified && NextToken().is(tok::coloncolon)) {
Nico Weberf9e37be2015-01-30 16:53:11 +00002592 // Don't let ParseOptionalCXXScopeSpecifier() "correct"
2593 // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
2594 // it will confuse this recovery logic.
2595 ColonProtectionRAIIObject ColonRAII(*this, false);
2596
Richard Smithefa6f732014-09-06 02:06:12 +00002597 if (SS.isSet()) {
2598 AnnotateScopeToken(SS, /*NewAnnotation*/true);
2599 SS.clear();
2600 }
2601 if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, EnteringContext))
2602 return true;
Nico Weber7f8ec522015-02-02 05:33:50 +00002603 if (SS.isNotEmpty())
David Blaikieefdccaa2016-01-15 23:43:34 +00002604 ObjectType = nullptr;
Nico Weberd0045862015-01-30 04:05:15 +00002605 if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
Benjamin Kramer3012e592015-03-29 14:35:39 +00002606 !SS.isSet()) {
Richard Smithefa6f732014-09-06 02:06:12 +00002607 Diag(TildeLoc, diag::err_destructor_tilde_scope);
2608 return true;
2609 }
2610
2611 // Recover as if the tilde had been written before the identifier.
2612 Diag(TildeLoc, diag::err_destructor_tilde_scope)
2613 << FixItHint::CreateRemoval(TildeLoc)
2614 << FixItHint::CreateInsertion(Tok.getLocation(), "~");
Richard Smith64e033f2015-01-15 00:48:52 +00002615
2616 // Temporarily enter the scope for the rest of this function.
2617 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
2618 DeclScopeObj.EnterDeclaratorScope();
Richard Smithefa6f732014-09-06 02:06:12 +00002619 }
2620
Douglas Gregor7861a802009-11-03 01:35:08 +00002621 // Parse the class-name (or template-name in a simple-template-id).
2622 IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2623 SourceLocation ClassNameLoc = ConsumeToken();
Richard Smithefa6f732014-09-06 02:06:12 +00002624
Douglas Gregorb22ee882010-05-05 05:58:24 +00002625 if (TemplateSpecified || Tok.is(tok::less)) {
David Blaikieefdccaa2016-01-15 23:43:34 +00002626 Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
Abramo Bagnara7945c982012-01-27 09:46:47 +00002627 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2628 ClassName, ClassNameLoc,
2629 EnteringContext, ObjectType,
2630 Result, TemplateSpecified);
Douglas Gregor30d60cb2009-11-03 19:44:04 +00002631 }
Richard Smithefa6f732014-09-06 02:06:12 +00002632
Douglas Gregor7861a802009-11-03 01:35:08 +00002633 // Note that this is a destructor name.
John McCallba7bf592010-08-24 05:47:05 +00002634 ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
2635 ClassNameLoc, getCurScope(),
2636 SS, ObjectType,
2637 EnteringContext);
Douglas Gregorfe17d252010-02-16 19:09:40 +00002638 if (!Ty)
Douglas Gregor7861a802009-11-03 01:35:08 +00002639 return true;
Douglas Gregorfe17d252010-02-16 19:09:40 +00002640
Douglas Gregor7861a802009-11-03 01:35:08 +00002641 Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
Douglas Gregor7861a802009-11-03 01:35:08 +00002642 return false;
2643 }
2644
Douglas Gregor30d60cb2009-11-03 19:44:04 +00002645 Diag(Tok, diag::err_expected_unqualified_id)
David Blaikiebbafb8a2012-03-11 07:00:24 +00002646 << getLangOpts().CPlusPlus;
Douglas Gregor7861a802009-11-03 01:35:08 +00002647 return true;
2648}
2649
Sebastian Redlbd150f42008-11-21 19:14:01 +00002650/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2651/// memory in a typesafe manner and call constructors.
Mike Stump11289f42009-09-09 15:08:12 +00002652///
Chris Lattner109faf22009-01-04 21:25:24 +00002653/// This method is called to parse the new expression after the optional :: has
2654/// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
2655/// is its location. Otherwise, "Start" is the location of the 'new' token.
Sebastian Redlbd150f42008-11-21 19:14:01 +00002656///
2657/// new-expression:
2658/// '::'[opt] 'new' new-placement[opt] new-type-id
2659/// new-initializer[opt]
2660/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2661/// new-initializer[opt]
2662///
2663/// new-placement:
2664/// '(' expression-list ')'
2665///
Sebastian Redl351bb782008-12-02 14:43:59 +00002666/// new-type-id:
2667/// type-specifier-seq new-declarator[opt]
Douglas Gregora3a020a2011-04-15 19:40:02 +00002668/// [GNU] attributes type-specifier-seq new-declarator[opt]
Sebastian Redl351bb782008-12-02 14:43:59 +00002669///
2670/// new-declarator:
2671/// ptr-operator new-declarator[opt]
2672/// direct-new-declarator
2673///
Sebastian Redlbd150f42008-11-21 19:14:01 +00002674/// new-initializer:
2675/// '(' expression-list[opt] ')'
Sebastian Redl3da34892011-06-05 12:23:16 +00002676/// [C++0x] braced-init-list
Sebastian Redlbd150f42008-11-21 19:14:01 +00002677///
John McCalldadc5752010-08-24 06:29:42 +00002678ExprResult
Chris Lattner109faf22009-01-04 21:25:24 +00002679Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
2680 assert(Tok.is(tok::kw_new) && "expected 'new' token");
2681 ConsumeToken(); // Consume 'new'
Sebastian Redlbd150f42008-11-21 19:14:01 +00002682
2683 // A '(' now can be a new-placement or the '(' wrapping the type-id in the
2684 // second form of new-expression. It can't be a new-type-id.
2685
Benjamin Kramerf0623432012-08-23 22:51:59 +00002686 ExprVector PlacementArgs;
Sebastian Redlbd150f42008-11-21 19:14:01 +00002687 SourceLocation PlacementLParen, PlacementRParen;
2688
Douglas Gregorf2753b32010-07-13 15:54:32 +00002689 SourceRange TypeIdParens;
John McCall084e83d2011-03-24 11:26:52 +00002690 DeclSpec DS(AttrFactory);
Argyrios Kyrtzidis3ff13572011-06-28 03:01:23 +00002691 Declarator DeclaratorInfo(DS, Declarator::CXXNewContext);
Sebastian Redlbd150f42008-11-21 19:14:01 +00002692 if (Tok.is(tok::l_paren)) {
2693 // If it turns out to be a placement, we change the type location.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002694 BalancedDelimiterTracker T(*this, tok::l_paren);
2695 T.consumeOpen();
2696 PlacementLParen = T.getOpenLocation();
Sebastian Redl351bb782008-12-02 14:43:59 +00002697 if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00002698 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
Sebastian Redld65cea82008-12-11 22:51:44 +00002699 return ExprError();
Sebastian Redl351bb782008-12-02 14:43:59 +00002700 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002701
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002702 T.consumeClose();
2703 PlacementRParen = T.getCloseLocation();
Sebastian Redl351bb782008-12-02 14:43:59 +00002704 if (PlacementRParen.isInvalid()) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00002705 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
Sebastian Redld65cea82008-12-11 22:51:44 +00002706 return ExprError();
Sebastian Redl351bb782008-12-02 14:43:59 +00002707 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002708
Sebastian Redl351bb782008-12-02 14:43:59 +00002709 if (PlacementArgs.empty()) {
Sebastian Redlbd150f42008-11-21 19:14:01 +00002710 // Reset the placement locations. There was no placement.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002711 TypeIdParens = T.getRange();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002712 PlacementLParen = PlacementRParen = SourceLocation();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002713 } else {
2714 // We still need the type.
2715 if (Tok.is(tok::l_paren)) {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002716 BalancedDelimiterTracker T(*this, tok::l_paren);
2717 T.consumeOpen();
Douglas Gregora3a020a2011-04-15 19:40:02 +00002718 MaybeParseGNUAttributes(DeclaratorInfo);
Sebastian Redl351bb782008-12-02 14:43:59 +00002719 ParseSpecifierQualifierList(DS);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002720 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
Sebastian Redl351bb782008-12-02 14:43:59 +00002721 ParseDeclarator(DeclaratorInfo);
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002722 T.consumeClose();
2723 TypeIdParens = T.getRange();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002724 } else {
Douglas Gregora3a020a2011-04-15 19:40:02 +00002725 MaybeParseGNUAttributes(DeclaratorInfo);
Sebastian Redl351bb782008-12-02 14:43:59 +00002726 if (ParseCXXTypeSpecifierSeq(DS))
2727 DeclaratorInfo.setInvalidType(true);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002728 else {
2729 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
Sebastian Redl351bb782008-12-02 14:43:59 +00002730 ParseDeclaratorInternal(DeclaratorInfo,
2731 &Parser::ParseDirectNewDeclarator);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002732 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002733 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002734 }
2735 } else {
Sebastian Redl351bb782008-12-02 14:43:59 +00002736 // A new-type-id is a simplified type-id, where essentially the
2737 // direct-declarator is replaced by a direct-new-declarator.
Douglas Gregora3a020a2011-04-15 19:40:02 +00002738 MaybeParseGNUAttributes(DeclaratorInfo);
Sebastian Redl351bb782008-12-02 14:43:59 +00002739 if (ParseCXXTypeSpecifierSeq(DS))
2740 DeclaratorInfo.setInvalidType(true);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002741 else {
2742 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
Sebastian Redl351bb782008-12-02 14:43:59 +00002743 ParseDeclaratorInternal(DeclaratorInfo,
2744 &Parser::ParseDirectNewDeclarator);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002745 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002746 }
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002747 if (DeclaratorInfo.isInvalidType()) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00002748 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
Sebastian Redld65cea82008-12-11 22:51:44 +00002749 return ExprError();
Sebastian Redl351bb782008-12-02 14:43:59 +00002750 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002751
Sebastian Redl6047f072012-02-16 12:22:20 +00002752 ExprResult Initializer;
Sebastian Redlbd150f42008-11-21 19:14:01 +00002753
2754 if (Tok.is(tok::l_paren)) {
Sebastian Redl6047f072012-02-16 12:22:20 +00002755 SourceLocation ConstructorLParen, ConstructorRParen;
Benjamin Kramerf0623432012-08-23 22:51:59 +00002756 ExprVector ConstructorArgs;
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002757 BalancedDelimiterTracker T(*this, tok::l_paren);
2758 T.consumeOpen();
2759 ConstructorLParen = T.getOpenLocation();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002760 if (Tok.isNot(tok::r_paren)) {
2761 CommaLocsTy CommaLocs;
Francisco Lopes da Silva975a9f62015-01-21 16:24:11 +00002762 if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
2763 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(),
2764 DeclaratorInfo).get();
2765 Actions.CodeCompleteConstructor(getCurScope(),
2766 TypeRep.get()->getCanonicalTypeInternal(),
2767 DeclaratorInfo.getLocEnd(),
2768 ConstructorArgs);
2769 })) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00002770 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
Sebastian Redld65cea82008-12-11 22:51:44 +00002771 return ExprError();
Sebastian Redl351bb782008-12-02 14:43:59 +00002772 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002773 }
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002774 T.consumeClose();
2775 ConstructorRParen = T.getCloseLocation();
Sebastian Redl351bb782008-12-02 14:43:59 +00002776 if (ConstructorRParen.isInvalid()) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00002777 SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
Sebastian Redld65cea82008-12-11 22:51:44 +00002778 return ExprError();
Sebastian Redl351bb782008-12-02 14:43:59 +00002779 }
Sebastian Redl6047f072012-02-16 12:22:20 +00002780 Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
2781 ConstructorRParen,
Benjamin Kramer62b95d82012-08-23 21:35:17 +00002782 ConstructorArgs);
Richard Smith2bf7fdb2013-01-02 11:42:31 +00002783 } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
Richard Smith5d164bc2011-10-15 05:09:34 +00002784 Diag(Tok.getLocation(),
2785 diag::warn_cxx98_compat_generalized_initializer_lists);
Sebastian Redl6047f072012-02-16 12:22:20 +00002786 Initializer = ParseBraceInitializer();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002787 }
Sebastian Redl6047f072012-02-16 12:22:20 +00002788 if (Initializer.isInvalid())
2789 return Initializer;
Sebastian Redlbd150f42008-11-21 19:14:01 +00002790
Sebastian Redl6d4256c2009-03-15 17:47:39 +00002791 return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
Benjamin Kramer62b95d82012-08-23 21:35:17 +00002792 PlacementArgs, PlacementRParen,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002793 TypeIdParens, DeclaratorInfo, Initializer.get());
Sebastian Redlbd150f42008-11-21 19:14:01 +00002794}
2795
Sebastian Redlbd150f42008-11-21 19:14:01 +00002796/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2797/// passed to ParseDeclaratorInternal.
2798///
2799/// direct-new-declarator:
2800/// '[' expression ']'
2801/// direct-new-declarator '[' constant-expression ']'
2802///
Chris Lattner109faf22009-01-04 21:25:24 +00002803void Parser::ParseDirectNewDeclarator(Declarator &D) {
Sebastian Redlbd150f42008-11-21 19:14:01 +00002804 // Parse the array dimensions.
2805 bool first = true;
2806 while (Tok.is(tok::l_square)) {
Richard Smith7bdcc4a2012-04-10 01:32:12 +00002807 // An array-size expression can't start with a lambda.
2808 if (CheckProhibitedCXX11Attribute())
2809 continue;
2810
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002811 BalancedDelimiterTracker T(*this, tok::l_square);
2812 T.consumeOpen();
2813
John McCalldadc5752010-08-24 06:29:42 +00002814 ExprResult Size(first ? ParseExpression()
Sebastian Redl59b5e512008-12-11 21:36:32 +00002815 : ParseConstantExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002816 if (Size.isInvalid()) {
Sebastian Redlbd150f42008-11-21 19:14:01 +00002817 // Recover
Alexey Bataevee6507d2013-11-18 08:17:37 +00002818 SkipUntil(tok::r_square, StopAtSemi);
Sebastian Redlbd150f42008-11-21 19:14:01 +00002819 return;
2820 }
2821 first = false;
2822
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002823 T.consumeClose();
John McCall084e83d2011-03-24 11:26:52 +00002824
Bill Wendling44426052012-12-20 19:22:21 +00002825 // Attributes here appertain to the array type. C++11 [expr.new]p5.
Richard Smith7bdcc4a2012-04-10 01:32:12 +00002826 ParsedAttributes Attrs(AttrFactory);
Richard Smith89645bc2013-01-02 12:01:23 +00002827 MaybeParseCXX11Attributes(Attrs);
Richard Smith7bdcc4a2012-04-10 01:32:12 +00002828
John McCall084e83d2011-03-24 11:26:52 +00002829 D.AddTypeInfo(DeclaratorChunk::getArray(0,
John McCall53fa7142010-12-24 02:08:15 +00002830 /*static=*/false, /*star=*/false,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002831 Size.get(),
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002832 T.getOpenLocation(),
2833 T.getCloseLocation()),
Richard Smith7bdcc4a2012-04-10 01:32:12 +00002834 Attrs, T.getCloseLocation());
Sebastian Redlbd150f42008-11-21 19:14:01 +00002835
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002836 if (T.getCloseLocation().isInvalid())
Sebastian Redlbd150f42008-11-21 19:14:01 +00002837 return;
2838 }
2839}
2840
2841/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2842/// This ambiguity appears in the syntax of the C++ new operator.
2843///
2844/// new-expression:
2845/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2846/// new-initializer[opt]
2847///
2848/// new-placement:
2849/// '(' expression-list ')'
2850///
John McCall37ad5512010-08-23 06:44:23 +00002851bool Parser::ParseExpressionListOrTypeId(
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002852 SmallVectorImpl<Expr*> &PlacementArgs,
Chris Lattner109faf22009-01-04 21:25:24 +00002853 Declarator &D) {
Sebastian Redlbd150f42008-11-21 19:14:01 +00002854 // The '(' was already consumed.
2855 if (isTypeIdInParens()) {
Sebastian Redl351bb782008-12-02 14:43:59 +00002856 ParseSpecifierQualifierList(D.getMutableDeclSpec());
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002857 D.SetSourceRange(D.getDeclSpec().getSourceRange());
Sebastian Redl351bb782008-12-02 14:43:59 +00002858 ParseDeclarator(D);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002859 return D.isInvalidType();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002860 }
2861
2862 // It's not a type, it has to be an expression list.
2863 // Discard the comma locations - ActOnCXXNew has enough parameters.
2864 CommaLocsTy CommaLocs;
2865 return ParseExpressionList(PlacementArgs, CommaLocs);
2866}
2867
2868/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2869/// to free memory allocated by new.
2870///
Chris Lattner109faf22009-01-04 21:25:24 +00002871/// This method is called to parse the 'delete' expression after the optional
2872/// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
2873/// and "Start" is its location. Otherwise, "Start" is the location of the
2874/// 'delete' token.
2875///
Sebastian Redlbd150f42008-11-21 19:14:01 +00002876/// delete-expression:
2877/// '::'[opt] 'delete' cast-expression
2878/// '::'[opt] 'delete' '[' ']' cast-expression
John McCalldadc5752010-08-24 06:29:42 +00002879ExprResult
Chris Lattner109faf22009-01-04 21:25:24 +00002880Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
2881 assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
2882 ConsumeToken(); // Consume 'delete'
Sebastian Redlbd150f42008-11-21 19:14:01 +00002883
2884 // Array delete?
2885 bool ArrayDelete = false;
Richard Smith7bdcc4a2012-04-10 01:32:12 +00002886 if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
Richard Smith10c60722012-08-09 19:01:51 +00002887 // C++11 [expr.delete]p1:
2888 // Whenever the delete keyword is followed by empty square brackets, it
2889 // shall be interpreted as [array delete].
2890 // [Footnote: A lambda expression with a lambda-introducer that consists
2891 // of empty square brackets can follow the delete keyword if
2892 // the lambda expression is enclosed in parentheses.]
2893 // FIXME: Produce a better diagnostic if the '[]' is unambiguously a
2894 // lambda-introducer.
Sebastian Redlbd150f42008-11-21 19:14:01 +00002895 ArrayDelete = true;
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00002896 BalancedDelimiterTracker T(*this, tok::l_square);
2897
2898 T.consumeOpen();
2899 T.consumeClose();
2900 if (T.getCloseLocation().isInvalid())
Sebastian Redld65cea82008-12-11 22:51:44 +00002901 return ExprError();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002902 }
2903
John McCalldadc5752010-08-24 06:29:42 +00002904 ExprResult Operand(ParseCastExpression(false));
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002905 if (Operand.isInvalid())
Benjamin Kramer62b95d82012-08-23 21:35:17 +00002906 return Operand;
Sebastian Redlbd150f42008-11-21 19:14:01 +00002907
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002908 return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
Sebastian Redlbd150f42008-11-21 19:14:01 +00002909}
Sebastian Redlbaad4e72009-01-05 20:52:13 +00002910
Douglas Gregor29c42f22012-02-24 07:38:34 +00002911static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
2912 switch (kind) {
2913 default: llvm_unreachable("Not a known type trait");
Alp Toker95e7ff22014-01-01 05:57:51 +00002914#define TYPE_TRAIT_1(Spelling, Name, Key) \
2915case tok::kw_ ## Spelling: return UTT_ ## Name;
Alp Tokercbb90342013-12-13 20:49:58 +00002916#define TYPE_TRAIT_2(Spelling, Name, Key) \
2917case tok::kw_ ## Spelling: return BTT_ ## Name;
2918#include "clang/Basic/TokenKinds.def"
Alp Toker40f9b1c2013-12-12 21:23:03 +00002919#define TYPE_TRAIT_N(Spelling, Name, Key) \
2920 case tok::kw_ ## Spelling: return TT_ ## Name;
2921#include "clang/Basic/TokenKinds.def"
Douglas Gregor29c42f22012-02-24 07:38:34 +00002922 }
2923}
2924
John Wiegley6242b6a2011-04-28 00:16:57 +00002925static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
2926 switch(kind) {
2927 default: llvm_unreachable("Not a known binary type trait");
2928 case tok::kw___array_rank: return ATT_ArrayRank;
2929 case tok::kw___array_extent: return ATT_ArrayExtent;
2930 }
2931}
2932
John Wiegleyf9f65842011-04-25 06:54:41 +00002933static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
2934 switch(kind) {
David Blaikie83d382b2011-09-23 05:06:16 +00002935 default: llvm_unreachable("Not a known unary expression trait.");
John Wiegleyf9f65842011-04-25 06:54:41 +00002936 case tok::kw___is_lvalue_expr: return ET_IsLValueExpr;
2937 case tok::kw___is_rvalue_expr: return ET_IsRValueExpr;
2938 }
2939}
2940
Alp Toker40f9b1c2013-12-12 21:23:03 +00002941static unsigned TypeTraitArity(tok::TokenKind kind) {
2942 switch (kind) {
2943 default: llvm_unreachable("Not a known type trait");
2944#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
2945#include "clang/Basic/TokenKinds.def"
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00002946 }
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00002947}
2948
Douglas Gregor29c42f22012-02-24 07:38:34 +00002949/// \brief Parse the built-in type-trait pseudo-functions that allow
2950/// implementation of the TR1/C++11 type traits templates.
2951///
2952/// primary-expression:
Alp Toker40f9b1c2013-12-12 21:23:03 +00002953/// unary-type-trait '(' type-id ')'
2954/// binary-type-trait '(' type-id ',' type-id ')'
Douglas Gregor29c42f22012-02-24 07:38:34 +00002955/// type-trait '(' type-id-seq ')'
2956///
2957/// type-id-seq:
2958/// type-id ...[opt] type-id-seq[opt]
2959///
2960ExprResult Parser::ParseTypeTrait() {
Alp Toker40f9b1c2013-12-12 21:23:03 +00002961 tok::TokenKind Kind = Tok.getKind();
2962 unsigned Arity = TypeTraitArity(Kind);
2963
Douglas Gregor29c42f22012-02-24 07:38:34 +00002964 SourceLocation Loc = ConsumeToken();
2965
2966 BalancedDelimiterTracker Parens(*this, tok::l_paren);
Alp Toker383d2c42014-01-01 03:08:43 +00002967 if (Parens.expectAndConsume())
Douglas Gregor29c42f22012-02-24 07:38:34 +00002968 return ExprError();
2969
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002970 SmallVector<ParsedType, 2> Args;
Douglas Gregor29c42f22012-02-24 07:38:34 +00002971 do {
2972 // Parse the next type.
2973 TypeResult Ty = ParseTypeName();
2974 if (Ty.isInvalid()) {
2975 Parens.skipToEnd();
2976 return ExprError();
2977 }
2978
2979 // Parse the ellipsis, if present.
2980 if (Tok.is(tok::ellipsis)) {
2981 Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
2982 if (Ty.isInvalid()) {
2983 Parens.skipToEnd();
2984 return ExprError();
2985 }
2986 }
2987
2988 // Add this type to the list of arguments.
2989 Args.push_back(Ty.get());
Alp Tokera3ebe6e2013-12-17 14:12:37 +00002990 } while (TryConsumeToken(tok::comma));
2991
Douglas Gregor29c42f22012-02-24 07:38:34 +00002992 if (Parens.consumeClose())
2993 return ExprError();
Alp Toker40f9b1c2013-12-12 21:23:03 +00002994
2995 SourceLocation EndLoc = Parens.getCloseLocation();
2996
2997 if (Arity && Args.size() != Arity) {
2998 Diag(EndLoc, diag::err_type_trait_arity)
2999 << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
3000 return ExprError();
3001 }
3002
3003 if (!Arity && Args.empty()) {
3004 Diag(EndLoc, diag::err_type_trait_arity)
3005 << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
3006 return ExprError();
3007 }
3008
Alp Toker88f64e62013-12-13 21:19:30 +00003009 return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
Douglas Gregor29c42f22012-02-24 07:38:34 +00003010}
3011
John Wiegley6242b6a2011-04-28 00:16:57 +00003012/// ParseArrayTypeTrait - Parse the built-in array type-trait
3013/// pseudo-functions.
3014///
3015/// primary-expression:
3016/// [Embarcadero] '__array_rank' '(' type-id ')'
3017/// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
3018///
3019ExprResult Parser::ParseArrayTypeTrait() {
3020 ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
3021 SourceLocation Loc = ConsumeToken();
3022
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003023 BalancedDelimiterTracker T(*this, tok::l_paren);
Alp Toker383d2c42014-01-01 03:08:43 +00003024 if (T.expectAndConsume())
John Wiegley6242b6a2011-04-28 00:16:57 +00003025 return ExprError();
3026
3027 TypeResult Ty = ParseTypeName();
3028 if (Ty.isInvalid()) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00003029 SkipUntil(tok::comma, StopAtSemi);
3030 SkipUntil(tok::r_paren, StopAtSemi);
John Wiegley6242b6a2011-04-28 00:16:57 +00003031 return ExprError();
3032 }
3033
3034 switch (ATT) {
3035 case ATT_ArrayRank: {
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003036 T.consumeClose();
Craig Topper161e4db2014-05-21 06:02:52 +00003037 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003038 T.getCloseLocation());
John Wiegley6242b6a2011-04-28 00:16:57 +00003039 }
3040 case ATT_ArrayExtent: {
Alp Toker383d2c42014-01-01 03:08:43 +00003041 if (ExpectAndConsume(tok::comma)) {
Alexey Bataevee6507d2013-11-18 08:17:37 +00003042 SkipUntil(tok::r_paren, StopAtSemi);
John Wiegley6242b6a2011-04-28 00:16:57 +00003043 return ExprError();
3044 }
3045
3046 ExprResult DimExpr = ParseExpression();
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003047 T.consumeClose();
John Wiegley6242b6a2011-04-28 00:16:57 +00003048
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003049 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
3050 T.getCloseLocation());
John Wiegley6242b6a2011-04-28 00:16:57 +00003051 }
John Wiegley6242b6a2011-04-28 00:16:57 +00003052 }
David Blaikiee4d798f2012-01-20 21:50:17 +00003053 llvm_unreachable("Invalid ArrayTypeTrait!");
John Wiegley6242b6a2011-04-28 00:16:57 +00003054}
3055
John Wiegleyf9f65842011-04-25 06:54:41 +00003056/// ParseExpressionTrait - Parse built-in expression-trait
3057/// pseudo-functions like __is_lvalue_expr( xxx ).
3058///
3059/// primary-expression:
3060/// [Embarcadero] expression-trait '(' expression ')'
3061///
3062ExprResult Parser::ParseExpressionTrait() {
3063 ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
3064 SourceLocation Loc = ConsumeToken();
3065
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003066 BalancedDelimiterTracker T(*this, tok::l_paren);
Alp Toker383d2c42014-01-01 03:08:43 +00003067 if (T.expectAndConsume())
John Wiegleyf9f65842011-04-25 06:54:41 +00003068 return ExprError();
3069
3070 ExprResult Expr = ParseExpression();
3071
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003072 T.consumeClose();
John Wiegleyf9f65842011-04-25 06:54:41 +00003073
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003074 return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
3075 T.getCloseLocation());
John Wiegleyf9f65842011-04-25 06:54:41 +00003076}
3077
3078
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003079/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3080/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3081/// based on the context past the parens.
John McCalldadc5752010-08-24 06:29:42 +00003082ExprResult
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003083Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
John McCallba7bf592010-08-24 05:47:05 +00003084 ParsedType &CastTy,
Richard Smith87e11a42014-05-15 02:43:47 +00003085 BalancedDelimiterTracker &Tracker,
3086 ColonProtectionRAIIObject &ColonProt) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00003087 assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003088 assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
3089 assert(isTypeIdInParens() && "Not a type-id!");
3090
John McCalldadc5752010-08-24 06:29:42 +00003091 ExprResult Result(true);
David Blaikieefdccaa2016-01-15 23:43:34 +00003092 CastTy = nullptr;
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003093
3094 // We need to disambiguate a very ugly part of the C++ syntax:
3095 //
3096 // (T())x; - type-id
3097 // (T())*x; - type-id
3098 // (T())/x; - expression
3099 // (T()); - expression
3100 //
3101 // The bad news is that we cannot use the specialized tentative parser, since
3102 // it can only verify that the thing inside the parens can be parsed as
3103 // type-id, it is not useful for determining the context past the parens.
3104 //
3105 // The good news is that the parser can disambiguate this part without
Argyrios Kyrtzidis24ad6922009-05-22 15:12:46 +00003106 // making any unnecessary Action calls.
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003107 //
3108 // It uses a scheme similar to parsing inline methods. The parenthesized
3109 // tokens are cached, the context that follows is determined (possibly by
3110 // parsing a cast-expression), and then we re-introduce the cached tokens
3111 // into the token stream and parse them appropriately.
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003112
Mike Stump11289f42009-09-09 15:08:12 +00003113 ParenParseOption ParseAs;
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003114 CachedTokens Toks;
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003115
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003116 // Store the tokens of the parentheses. We will parse them after we determine
3117 // the context that follows them.
Argyrios Kyrtzidis8d7bdba2010-04-23 21:20:12 +00003118 if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003119 // We didn't find the ')' we expected.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003120 Tracker.consumeClose();
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003121 return ExprError();
3122 }
3123
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003124 if (Tok.is(tok::l_brace)) {
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003125 ParseAs = CompoundLiteral;
3126 } else {
3127 bool NotCastExpr;
Eli Friedmancf7530f2009-05-25 19:41:42 +00003128 if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
3129 NotCastExpr = true;
3130 } else {
3131 // Try parsing the cast-expression that may follow.
3132 // If it is not a cast-expression, NotCastExpr will be true and no token
3133 // will be consumed.
Richard Smith87e11a42014-05-15 02:43:47 +00003134 ColonProt.restore();
Eli Friedmancf7530f2009-05-25 19:41:42 +00003135 Result = ParseCastExpression(false/*isUnaryExpression*/,
3136 false/*isAddressofOperand*/,
John McCallba7bf592010-08-24 05:47:05 +00003137 NotCastExpr,
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00003138 // type-id has priority.
Kaelyn Uhrain77e21fc2012-01-25 20:49:08 +00003139 IsTypeCast);
Eli Friedmancf7530f2009-05-25 19:41:42 +00003140 }
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003141
3142 // If we parsed a cast-expression, it's really a type-id, otherwise it's
3143 // an expression.
3144 ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003145 }
3146
Alexey Bataev703a93c2016-02-04 04:22:09 +00003147 // Create a fake EOF to mark end of Toks buffer.
3148 Token AttrEnd;
3149 AttrEnd.startToken();
3150 AttrEnd.setKind(tok::eof);
3151 AttrEnd.setLocation(Tok.getLocation());
3152 AttrEnd.setEofData(Toks.data());
3153 Toks.push_back(AttrEnd);
3154
Mike Stump11289f42009-09-09 15:08:12 +00003155 // The current token should go after the cached tokens.
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003156 Toks.push_back(Tok);
3157 // Re-enter the stored parenthesized tokens into the token stream, so we may
3158 // parse them now.
David Blaikie2eabcc92016-02-09 18:52:09 +00003159 PP.EnterTokenStream(Toks, true /*DisableMacroExpansion*/);
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003160 // Drop the current token and bring the first cached one. It's the same token
3161 // as when we entered this function.
3162 ConsumeAnyToken();
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003163
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003164 if (ParseAs >= CompoundLiteral) {
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00003165 // Parse the type declarator.
3166 DeclSpec DS(AttrFactory);
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00003167 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
Richard Smith87e11a42014-05-15 02:43:47 +00003168 {
3169 ColonProtectionRAIIObject InnerColonProtection(*this);
3170 ParseSpecifierQualifierList(DS);
3171 ParseDeclarator(DeclaratorInfo);
3172 }
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003173
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003174 // Match the ')'.
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003175 Tracker.consumeClose();
Richard Smith87e11a42014-05-15 02:43:47 +00003176 ColonProt.restore();
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003177
Alexey Bataev703a93c2016-02-04 04:22:09 +00003178 // Consume EOF marker for Toks buffer.
3179 assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3180 ConsumeAnyToken();
3181
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003182 if (ParseAs == CompoundLiteral) {
3183 ExprType = CompoundLiteral;
Richard Smithaba8b362014-05-15 02:51:15 +00003184 if (DeclaratorInfo.isInvalidType())
3185 return ExprError();
3186
3187 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
Richard Smith87e11a42014-05-15 02:43:47 +00003188 return ParseCompoundLiteralExpression(Ty.get(),
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003189 Tracker.getOpenLocation(),
3190 Tracker.getCloseLocation());
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003191 }
Mike Stump11289f42009-09-09 15:08:12 +00003192
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003193 // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
3194 assert(ParseAs == CastExpr);
3195
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00003196 if (DeclaratorInfo.isInvalidType())
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003197 return ExprError();
3198
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003199 // Result is what ParseCastExpression returned earlier.
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003200 if (!Result.isInvalid())
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003201 Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
3202 DeclaratorInfo, CastTy,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003203 Tracker.getCloseLocation(), Result.get());
Benjamin Kramer62b95d82012-08-23 21:35:17 +00003204 return Result;
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003205 }
Mike Stump11289f42009-09-09 15:08:12 +00003206
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003207 // Not a compound literal, and not followed by a cast-expression.
3208 assert(ParseAs == SimpleExpr);
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003209
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003210 ExprType = SimpleExpr;
Argyrios Kyrtzidisf73f2d22009-05-22 21:09:47 +00003211 Result = ParseExpression();
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003212 if (!Result.isInvalid() && Tok.is(tok::r_paren))
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003213 Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003214 Tok.getLocation(), Result.get());
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003215
3216 // Match the ')'.
3217 if (Result.isInvalid()) {
Alexey Bataev703a93c2016-02-04 04:22:09 +00003218 while (Tok.isNot(tok::eof))
3219 ConsumeAnyToken();
3220 assert(Tok.getEofData() == AttrEnd.getEofData());
3221 ConsumeAnyToken();
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003222 return ExprError();
3223 }
Mike Stump11289f42009-09-09 15:08:12 +00003224
Douglas Gregore7a8e3b2011-10-12 16:37:45 +00003225 Tracker.consumeClose();
Alexey Bataev703a93c2016-02-04 04:22:09 +00003226 // Consume EOF marker for Toks buffer.
3227 assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3228 ConsumeAnyToken();
Benjamin Kramer62b95d82012-08-23 21:35:17 +00003229 return Result;
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00003230}