blob: b9314d242442d8e327e1eb921388c73175892c94 [file] [log] [blame]
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +00001//===--- ParseCXXInlineMethods.cpp - C++ class inline methods parsing------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements parsing for C++ class inline methods.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattner500d3292009-01-29 05:15:15 +000014#include "clang/Parse/ParseDiagnostic.h"
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000015#include "clang/Parse/Parser.h"
16#include "clang/Parse/DeclSpec.h"
17#include "clang/Parse/Scope.h"
18using namespace clang;
19
Sebastian Redld3a413d2009-04-26 20:35:05 +000020/// ParseCXXInlineMethodDef - We parsed and verified that the specified
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000021/// Declarator is a well formed C++ inline method definition. Now lex its body
22/// and store its tokens for parsing after the C++ class is complete.
Chris Lattnerb28317a2009-03-28 19:18:32 +000023Parser::DeclPtrTy
Douglas Gregor37b372b2009-08-20 22:52:58 +000024Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, Declarator &D,
25 const ParsedTemplateInfo &TemplateInfo) {
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000026 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
27 "This isn't a function declarator!");
Sebastian Redld3a413d2009-04-26 20:35:05 +000028 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) &&
29 "Current token not a '{', ':' or 'try'!");
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000030
Douglas Gregor37b372b2009-08-20 22:52:58 +000031 Action::MultiTemplateParamsArg TemplateParams(Actions,
32 TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->data() : 0,
33 TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->size() : 0);
John McCall67d1a672009-08-06 02:15:43 +000034 DeclPtrTy FnD;
35 if (D.getDeclSpec().isFriendSpecified())
Douglas Gregor37b372b2009-08-20 22:52:58 +000036 // FIXME: Friend templates
John McCallbbbcdd92009-09-11 21:02:39 +000037 FnD = Actions.ActOnFriendFunctionDecl(CurScope, D, true, move(TemplateParams));
Douglas Gregor37b372b2009-08-20 22:52:58 +000038 else // FIXME: pass template information through
Mike Stump1eb44332009-09-09 15:08:12 +000039 FnD = Actions.ActOnCXXMemberDeclarator(CurScope, AS, D,
Sebastian Redld1a78462009-11-24 23:38:44 +000040 move(TemplateParams), 0, 0,
41 /*IsDefinition*/true);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000042
Eli Friedmand33133c2009-07-22 21:45:50 +000043 HandleMemberFunctionDefaultArgs(D, FnD);
44
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000045 // Consume the tokens and store them for later parsing.
46
Douglas Gregor6569d682009-05-27 23:11:45 +000047 getCurrentClass().MethodDefs.push_back(LexedMethod(FnD));
Mike Stump1eb44332009-09-09 15:08:12 +000048 getCurrentClass().MethodDefs.back().TemplateScope
Douglas Gregord83d0402009-08-22 00:34:47 +000049 = CurScope->isTemplateParamScope();
Douglas Gregor6569d682009-05-27 23:11:45 +000050 CachedTokens &Toks = getCurrentClass().MethodDefs.back().Toks;
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000051
Sebastian Redld3a413d2009-04-26 20:35:05 +000052 tok::TokenKind kind = Tok.getKind();
53 // We may have a constructor initializer or function-try-block here.
54 if (kind == tok::colon || kind == tok::kw_try) {
Douglas Gregor7ad83902008-11-05 04:29:56 +000055 // Consume everything up to (and including) the left brace.
Douglas Gregor72b505b2008-12-16 21:30:33 +000056 if (!ConsumeAndStoreUntil(tok::l_brace, tok::unknown, Toks, tok::semi)) {
Douglas Gregor3f08d182008-11-10 16:59:40 +000057 // We didn't find the left-brace we expected after the
Mike Stump1eb44332009-09-09 15:08:12 +000058 // constructor initializer.
Douglas Gregor3f08d182008-11-10 16:59:40 +000059 if (Tok.is(tok::semi)) {
60 // We found a semicolon; complain, consume the semicolon, and
61 // don't try to parse this method later.
62 Diag(Tok.getLocation(), diag::err_expected_lbrace);
63 ConsumeAnyToken();
Douglas Gregor6569d682009-05-27 23:11:45 +000064 getCurrentClass().MethodDefs.pop_back();
Douglas Gregor3f08d182008-11-10 16:59:40 +000065 return FnD;
66 }
67 }
68
Douglas Gregor7ad83902008-11-05 04:29:56 +000069 } else {
Mike Stump1eb44332009-09-09 15:08:12 +000070 // Begin by storing the '{' token.
Douglas Gregor7ad83902008-11-05 04:29:56 +000071 Toks.push_back(Tok);
72 ConsumeBrace();
73 }
74 // Consume everything up to (and including) the matching right brace.
Douglas Gregor72b505b2008-12-16 21:30:33 +000075 ConsumeAndStoreUntil(tok::r_brace, tok::unknown, Toks);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000076
Sebastian Redld3a413d2009-04-26 20:35:05 +000077 // If we're in a function-try-block, we need to store all the catch blocks.
78 if (kind == tok::kw_try) {
79 while (Tok.is(tok::kw_catch)) {
80 ConsumeAndStoreUntil(tok::l_brace, tok::unknown, Toks);
81 ConsumeAndStoreUntil(tok::r_brace, tok::unknown, Toks);
82 }
83 }
84
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +000085 return FnD;
86}
87
Douglas Gregor72b505b2008-12-16 21:30:33 +000088/// ParseLexedMethodDeclarations - We finished parsing the member
89/// specification of a top (non-nested) C++ class. Now go over the
90/// stack of method declarations with some parts for which parsing was
91/// delayed (such as default arguments) and parse them.
Douglas Gregor6569d682009-05-27 23:11:45 +000092void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) {
93 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
94 ParseScope TemplateScope(this, Scope::TemplateParamScope, HasTemplateScope);
95 if (HasTemplateScope)
96 Actions.ActOnReenterTemplateScope(CurScope, Class.TagOrTemplate);
97
98 bool HasClassScope = !Class.TopLevelClass;
99 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
100 HasClassScope);
101
102 for (; !Class.MethodDecls.empty(); Class.MethodDecls.pop_front()) {
103 LateParsedMethodDeclaration &LM = Class.MethodDecls.front();
Mike Stump1eb44332009-09-09 15:08:12 +0000104
Douglas Gregord83d0402009-08-22 00:34:47 +0000105 // If this is a member template, introduce the template parameter scope.
106 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
107 if (LM.TemplateScope)
108 Actions.ActOnReenterTemplateScope(CurScope, LM.Method);
Mike Stump1eb44332009-09-09 15:08:12 +0000109
Douglas Gregor72b505b2008-12-16 21:30:33 +0000110 // Start the delayed C++ method declaration
111 Actions.ActOnStartDelayedCXXMethodDeclaration(CurScope, LM.Method);
112
113 // Introduce the parameters into scope and parse their default
114 // arguments.
Mike Stump1eb44332009-09-09 15:08:12 +0000115 ParseScope PrototypeScope(this,
Douglas Gregor3218c4b2009-01-09 22:42:13 +0000116 Scope::FunctionPrototypeScope|Scope::DeclScope);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000117 for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) {
118 // Introduce the parameter into scope.
119 Actions.ActOnDelayedCXXMethodParameter(CurScope, LM.DefaultArgs[I].Param);
120
121 if (CachedTokens *Toks = LM.DefaultArgs[I].Toks) {
122 // Parse the default argument from its saved token stream.
123 Toks->push_back(Tok); // So that the current token doesn't get lost
124 PP.EnterTokenStream(&Toks->front(), Toks->size(), true, false);
125
126 // Consume the previously-pushed token.
127 ConsumeAnyToken();
128
129 // Consume the '='.
130 assert(Tok.is(tok::equal) && "Default argument not starting with '='");
131 SourceLocation EqualLoc = ConsumeToken();
132
133 OwningExprResult DefArgResult(ParseAssignmentExpression());
134 if (DefArgResult.isInvalid())
135 Actions.ActOnParamDefaultArgumentError(LM.DefaultArgs[I].Param);
136 else
137 Actions.ActOnParamDefaultArgument(LM.DefaultArgs[I].Param, EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000138 move(DefArgResult));
Douglas Gregor72b505b2008-12-16 21:30:33 +0000139 delete Toks;
140 LM.DefaultArgs[I].Toks = 0;
141 }
142 }
143 PrototypeScope.Exit();
144
145 // Finish the delayed C++ method declaration.
146 Actions.ActOnFinishDelayedCXXMethodDeclaration(CurScope, LM.Method);
147 }
Douglas Gregor6569d682009-05-27 23:11:45 +0000148
149 for (unsigned I = 0, N = Class.NestedClasses.size(); I != N; ++I)
150 ParseLexedMethodDeclarations(*Class.NestedClasses[I]);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000151}
152
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000153/// ParseLexedMethodDefs - We finished parsing the member specification of a top
154/// (non-nested) C++ class. Now go over the stack of lexed methods that were
155/// collected during its parsing and parse them all.
Douglas Gregor6569d682009-05-27 23:11:45 +0000156void Parser::ParseLexedMethodDefs(ParsingClass &Class) {
157 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
158 ParseScope TemplateScope(this, Scope::TemplateParamScope, HasTemplateScope);
159 if (HasTemplateScope)
160 Actions.ActOnReenterTemplateScope(CurScope, Class.TagOrTemplate);
161
162 bool HasClassScope = !Class.TopLevelClass;
163 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
164 HasClassScope);
165
166 for (; !Class.MethodDefs.empty(); Class.MethodDefs.pop_front()) {
167 LexedMethod &LM = Class.MethodDefs.front();
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000168
Douglas Gregord83d0402009-08-22 00:34:47 +0000169 // If this is a member template, introduce the template parameter scope.
170 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
171 if (LM.TemplateScope)
172 Actions.ActOnReenterTemplateScope(CurScope, LM.D);
Mike Stump1eb44332009-09-09 15:08:12 +0000173
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000174 assert(!LM.Toks.empty() && "Empty body!");
175 // Append the current token at the end of the new token stream so that it
176 // doesn't get lost.
177 LM.Toks.push_back(Tok);
Douglas Gregorefd5bda2009-08-24 11:57:43 +0000178 PP.EnterTokenStream(LM.Toks.data(), LM.Toks.size(), true, false);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000179
180 // Consume the previously pushed token.
181 ConsumeAnyToken();
Sebastian Redld3a413d2009-04-26 20:35:05 +0000182 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try))
183 && "Inline method not starting with '{', ':' or 'try'");
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000184
185 // Parse the method body. Function body parsing code is similar enough
186 // to be re-used for method bodies as well.
Douglas Gregor8935b8b2008-12-10 06:34:36 +0000187 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000188 Actions.ActOnStartOfFunctionDef(CurScope, LM.D);
189
Sebastian Redld3a413d2009-04-26 20:35:05 +0000190 if (Tok.is(tok::kw_try)) {
191 ParseFunctionTryBlock(LM.D);
Sebastian Redlde1b60a2009-04-26 21:08:36 +0000192 continue;
Sebastian Redld3a413d2009-04-26 20:35:05 +0000193 }
Douglas Gregor7ad83902008-11-05 04:29:56 +0000194 if (Tok.is(tok::colon))
195 ParseConstructorInitializer(LM.D);
Fariborz Jahanian0849d382009-07-14 20:06:22 +0000196 else
Fariborz Jahanian393612e2009-07-21 22:36:06 +0000197 Actions.ActOnDefaultCtorInitializers(LM.D);
Fariborz Jahaniand01c9152009-07-14 18:24:21 +0000198
Chris Lattner40e9bc82009-03-05 00:49:17 +0000199 // FIXME: What if ParseConstructorInitializer doesn't leave us with a '{'??
200 ParseFunctionStatementBody(LM.D);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000201 }
Douglas Gregor6569d682009-05-27 23:11:45 +0000202
203 for (unsigned I = 0, N = Class.NestedClasses.size(); I != N; ++I)
204 ParseLexedMethodDefs(*Class.NestedClasses[I]);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000205}
206
207/// ConsumeAndStoreUntil - Consume and store the token at the passed token
Douglas Gregor72b505b2008-12-16 21:30:33 +0000208/// container until the token 'T' is reached (which gets
Mike Stump1eb44332009-09-09 15:08:12 +0000209/// consumed/stored too, if ConsumeFinalToken).
Douglas Gregor3f08d182008-11-10 16:59:40 +0000210/// If EarlyAbortIf is specified, then we will stop early if we find that
211/// token at the top level.
Douglas Gregor72b505b2008-12-16 21:30:33 +0000212/// Returns true if token 'T1' or 'T2' was found.
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000213/// NOTE: This is a specialized version of Parser::SkipUntil.
Douglas Gregor72b505b2008-12-16 21:30:33 +0000214bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
215 CachedTokens &Toks,
216 tok::TokenKind EarlyAbortIf,
217 bool ConsumeFinalToken) {
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000218 // We always want this function to consume at least one token if the first
219 // token isn't T and if not at EOF.
220 bool isFirstTokenConsumed = true;
221 while (1) {
222 // If we found one of the tokens, stop and return true.
Douglas Gregor72b505b2008-12-16 21:30:33 +0000223 if (Tok.is(T1) || Tok.is(T2)) {
224 if (ConsumeFinalToken) {
225 Toks.push_back(Tok);
226 ConsumeAnyToken();
227 }
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000228 return true;
229 }
230
Douglas Gregor3f08d182008-11-10 16:59:40 +0000231 // If we found the early-abort token, return.
232 if (Tok.is(EarlyAbortIf))
233 return false;
234
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000235 switch (Tok.getKind()) {
236 case tok::eof:
237 // Ran out of tokens.
238 return false;
239
240 case tok::l_paren:
241 // Recursively consume properly-nested parens.
242 Toks.push_back(Tok);
243 ConsumeParen();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000244 ConsumeAndStoreUntil(tok::r_paren, tok::unknown, Toks);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000245 break;
246 case tok::l_square:
247 // Recursively consume properly-nested square brackets.
248 Toks.push_back(Tok);
249 ConsumeBracket();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000250 ConsumeAndStoreUntil(tok::r_square, tok::unknown, Toks);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000251 break;
252 case tok::l_brace:
253 // Recursively consume properly-nested braces.
254 Toks.push_back(Tok);
255 ConsumeBrace();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000256 ConsumeAndStoreUntil(tok::r_brace, tok::unknown, Toks);
Argyrios Kyrtzidis4cc18a42008-06-24 22:12:16 +0000257 break;
258
259 // Okay, we found a ']' or '}' or ')', which we think should be balanced.
260 // Since the user wasn't looking for this token (if they were, it would
261 // already be handled), this isn't balanced. If there is a LHS token at a
262 // higher level, we will assume that this matches the unbalanced token
263 // and return it. Otherwise, this is a spurious RHS token, which we skip.
264 case tok::r_paren:
265 if (ParenCount && !isFirstTokenConsumed)
266 return false; // Matches something.
267 Toks.push_back(Tok);
268 ConsumeParen();
269 break;
270 case tok::r_square:
271 if (BracketCount && !isFirstTokenConsumed)
272 return false; // Matches something.
273 Toks.push_back(Tok);
274 ConsumeBracket();
275 break;
276 case tok::r_brace:
277 if (BraceCount && !isFirstTokenConsumed)
278 return false; // Matches something.
279 Toks.push_back(Tok);
280 ConsumeBrace();
281 break;
282
283 case tok::string_literal:
284 case tok::wide_string_literal:
285 Toks.push_back(Tok);
286 ConsumeStringToken();
287 break;
288 default:
289 // consume this token.
290 Toks.push_back(Tok);
291 ConsumeToken();
292 break;
293 }
294 isFirstTokenConsumed = false;
295 }
296}