lib/Parse/ParseCXXInlineMethods.cpp

   1 //===--- 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
  14 #include "clang/Parse/ParseDiagnostic.h"
  15 #include "clang/Parse/Parser.h"
  16 #include "clang/Sema/DeclSpec.h"
  17 #include "clang/Sema/Scope.h"
  18 using namespace clang;
  19
  20 /// ParseCXXInlineMethodDef - We parsed and verified that the specified
  21 /// 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.
  23 Decl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, ParsingDeclarator &D,
  24                                 const ParsedTemplateInfo &TemplateInfo,
  25                                 const VirtSpecifiers& VS) {
  26   assert(D.isFunctionDeclarator() && "This isn't a function declarator!");
  27   assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) &&
  28          "Current token not a '{', ':' or 'try'!");
  29
  30   MultiTemplateParamsArg TemplateParams(Actions,
  31           TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->data() : 0,
  32           TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->size() : 0);
  33
  34   Decl *FnD;
  35   if (D.getDeclSpec().isFriendSpecified())
  36     // FIXME: Friend templates
  37     FnD = Actions.ActOnFriendFunctionDecl(getCurScope(), D, true,
  38                                           move(TemplateParams));
  39   else { // FIXME: pass template information through
  40     if (VS.isOverrideSpecified())
  41       Diag(VS.getOverrideLoc(), diag::ext_override_inline) << "override";
  42     if (VS.isFinalSpecified())
  43       Diag(VS.getFinalLoc(), diag::ext_override_inline) << "final";
  44     if (VS.isNewSpecified())
  45       Diag(VS.getNewLoc(), diag::ext_override_inline) << "new";
  46
  47     FnD = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, D,
  48                                            move(TemplateParams), 0,
  49                                            VS, 0, /*IsDefinition*/true);
  50   }
  51
  52   HandleMemberFunctionDefaultArgs(D, FnD);
  53
  54   D.complete(FnD);
  55
  56   // Consume the tokens and store them for later parsing.
  57
  58   LexedMethod* LM = new LexedMethod(this, FnD);
  59   getCurrentClass().LateParsedDeclarations.push_back(LM);
  60   LM->TemplateScope = getCurScope()->isTemplateParamScope();
  61   CachedTokens &Toks = LM->Toks;
  62
  63   tok::TokenKind kind = Tok.getKind();
  64   // We may have a constructor initializer or function-try-block here.
  65   if (kind == tok::colon || kind == tok::kw_try) {
  66     // Consume everything up to (and including) the left brace.
  67     if (!ConsumeAndStoreUntil(tok::l_brace, Toks)) {
  68       // We didn't find the left-brace we expected after the
  69       // constructor initializer.
  70       if (Tok.is(tok::semi)) {
  71         // We found a semicolon; complain, consume the semicolon, and
  72         // don't try to parse this method later.
  73         Diag(Tok.getLocation(), diag::err_expected_lbrace);
  74         ConsumeAnyToken();
  75         delete getCurrentClass().LateParsedDeclarations.back();
  76         getCurrentClass().LateParsedDeclarations.pop_back();
  77         return FnD;
  78       }
  79     }
  80
  81   } else {
  82     // Begin by storing the '{' token.
  83     Toks.push_back(Tok);
  84     ConsumeBrace();
  85   }
  86   // Consume everything up to (and including) the matching right brace.
  87   ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
  88
  89   // If we're in a function-try-block, we need to store all the catch blocks.
  90   if (kind == tok::kw_try) {
  91     while (Tok.is(tok::kw_catch)) {
  92       ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
  93       ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
  94     }
  95   }
  96
  97   return FnD;
  98 }
  99
 100 Parser::LateParsedDeclaration::~LateParsedDeclaration() {}
 101 void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {}
 102 void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {}
 103
 104 Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C)
 105   : Self(P), Class(C) {}
 106
 107 Parser::LateParsedClass::~LateParsedClass() {
 108   Self->DeallocateParsedClasses(Class);
 109 }
 110
 111 void Parser::LateParsedClass::ParseLexedMethodDeclarations() {
 112   Self->ParseLexedMethodDeclarations(*Class);
 113 }
 114
 115 void Parser::LateParsedClass::ParseLexedMethodDefs() {
 116   Self->ParseLexedMethodDefs(*Class);
 117 }
 118
 119 void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() {
 120   Self->ParseLexedMethodDeclaration(*this);
 121 }
 122
 123 void Parser::LexedMethod::ParseLexedMethodDefs() {
 124   Self->ParseLexedMethodDef(*this);
 125 }
 126
 127 /// ParseLexedMethodDeclarations - We finished parsing the member
 128 /// specification of a top (non-nested) C++ class. Now go over the
 129 /// stack of method declarations with some parts for which parsing was
 130 /// delayed (such as default arguments) and parse them.
 131 void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) {
 132   bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
 133   ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope);
 134   if (HasTemplateScope)
 135     Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
 136
 137   // The current scope is still active if we're the top-level class.
 138   // Otherwise we'll need to push and enter a new scope.
 139   bool HasClassScope = !Class.TopLevelClass;
 140   ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
 141                         HasClassScope);
 142   if (HasClassScope)
 143     Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate);
 144
 145   for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
 146     Class.LateParsedDeclarations[i]->ParseLexedMethodDeclarations();
 147   }
 148
 149   if (HasClassScope)
 150     Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate);
 151 }
 152
 153 void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) {
 154   // If this is a member template, introduce the template parameter scope.
 155   ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
 156   if (LM.TemplateScope)
 157     Actions.ActOnReenterTemplateScope(getCurScope(), LM.Method);
 158
 159   // Start the delayed C++ method declaration
 160   Actions.ActOnStartDelayedCXXMethodDeclaration(getCurScope(), LM.Method);
 161
 162   // Introduce the parameters into scope and parse their default
 163   // arguments.
 164   ParseScope PrototypeScope(this,
 165                             Scope::FunctionPrototypeScope|Scope::DeclScope);
 166   for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) {
 167     // Introduce the parameter into scope.
 168     Actions.ActOnDelayedCXXMethodParameter(getCurScope(), LM.DefaultArgs[I].Param);
 169
 170     if (CachedTokens *Toks = LM.DefaultArgs[I].Toks) {
 171       // Save the current token position.
 172       SourceLocation origLoc = Tok.getLocation();
 173
 174       // Parse the default argument from its saved token stream.
 175       Toks->push_back(Tok); // So that the current token doesn't get lost
 176       PP.EnterTokenStream(&Toks->front(), Toks->size(), true, false);
 177
 178       // Consume the previously-pushed token.
 179       ConsumeAnyToken();
 180
 181       // Consume the '='.
 182       assert(Tok.is(tok::equal) && "Default argument not starting with '='");
 183       SourceLocation EqualLoc = ConsumeToken();
 184
 185       // The argument isn't actually potentially evaluated unless it is
 186       // used.
 187       EnterExpressionEvaluationContext Eval(Actions,
 188                                             Sema::PotentiallyEvaluatedIfUsed);
 189
 190       ExprResult DefArgResult(ParseAssignmentExpression());
 191       if (DefArgResult.isInvalid())
 192         Actions.ActOnParamDefaultArgumentError(LM.DefaultArgs[I].Param);
 193       else {
 194         if (Tok.is(tok::cxx_defaultarg_end))
 195           ConsumeToken();
 196         else
 197           Diag(Tok.getLocation(), diag::err_default_arg_unparsed);
 198         Actions.ActOnParamDefaultArgument(LM.DefaultArgs[I].Param, EqualLoc,
 199                                           DefArgResult.take());
 200       }
 201
 202       assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc,
 203                                                          Tok.getLocation()) &&
 204              "ParseAssignmentExpression went over the default arg tokens!");
 205       // There could be leftover tokens (e.g. because of an error).
 206       // Skip through until we reach the original token position.
 207       while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof))
 208         ConsumeAnyToken();
 209
 210       delete Toks;
 211       LM.DefaultArgs[I].Toks = 0;
 212     }
 213   }
 214   PrototypeScope.Exit();
 215
 216   // Finish the delayed C++ method declaration.
 217   Actions.ActOnFinishDelayedCXXMethodDeclaration(getCurScope(), LM.Method);
 218 }
 219
 220 /// ParseLexedMethodDefs - We finished parsing the member specification of a top
 221 /// (non-nested) C++ class. Now go over the stack of lexed methods that were
 222 /// collected during its parsing and parse them all.
 223 void Parser::ParseLexedMethodDefs(ParsingClass &Class) {
 224   bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
 225   ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope);
 226   if (HasTemplateScope)
 227     Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
 228
 229   bool HasClassScope = !Class.TopLevelClass;
 230   ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
 231                         HasClassScope);
 232
 233   for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
 234     Class.LateParsedDeclarations[i]->ParseLexedMethodDefs();
 235   }
 236 }
 237
 238 void Parser::ParseLexedMethodDef(LexedMethod &LM) {
 239   // If this is a member template, introduce the template parameter scope.
 240   ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
 241   if (LM.TemplateScope)
 242     Actions.ActOnReenterTemplateScope(getCurScope(), LM.D);
 243
 244   // Save the current token position.
 245   SourceLocation origLoc = Tok.getLocation();
 246
 247   assert(!LM.Toks.empty() && "Empty body!");
 248   // Append the current token at the end of the new token stream so that it
 249   // doesn't get lost.
 250   LM.Toks.push_back(Tok);
 251   PP.EnterTokenStream(LM.Toks.data(), LM.Toks.size(), true, false);
 252
 253   // Consume the previously pushed token.
 254   ConsumeAnyToken();
 255   assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try))
 256          && "Inline method not starting with '{', ':' or 'try'");
 257
 258   // Parse the method body. Function body parsing code is similar enough
 259   // to be re-used for method bodies as well.
 260   ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope);
 261   Actions.ActOnStartOfFunctionDef(getCurScope(), LM.D);
 262
 263   if (Tok.is(tok::kw_try)) {
 264     ParseFunctionTryBlock(LM.D);
 265     assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc,
 266                                                          Tok.getLocation()) &&
 267            "ParseFunctionTryBlock went over the cached tokens!");
 268     // There could be leftover tokens (e.g. because of an error).
 269     // Skip through until we reach the original token position.
 270     while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof))
 271       ConsumeAnyToken();
 272     return;
 273   }
 274   if (Tok.is(tok::colon)) {
 275     ParseConstructorInitializer(LM.D);
 276
 277     // Error recovery.
 278     if (!Tok.is(tok::l_brace)) {
 279       Actions.ActOnFinishFunctionBody(LM.D, 0);
 280       return;
 281     }
 282   } else
 283     Actions.ActOnDefaultCtorInitializers(LM.D);
 284
 285   ParseFunctionStatementBody(LM.D);
 286
 287   if (Tok.getLocation() != origLoc) {
 288     // Due to parsing error, we either went over the cached tokens or
 289     // there are still cached tokens left. If it's the latter case skip the
 290     // leftover tokens.
 291     // Since this is an uncommon situation that should be avoided, use the
 292     // expensive isBeforeInTranslationUnit call.
 293     if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(),
 294                                                         origLoc))
 295       while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof))
 296         ConsumeAnyToken();
 297
 298   }
 299 }
 300
 301 /// ConsumeAndStoreUntil - Consume and store the token at the passed token
 302 /// container until the token 'T' is reached (which gets
 303 /// consumed/stored too, if ConsumeFinalToken).
 304 /// If StopAtSemi is true, then we will stop early at a ';' character.
 305 /// Returns true if token 'T1' or 'T2' was found.
 306 /// NOTE: This is a specialized version of Parser::SkipUntil.
 307 bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
 308                                   CachedTokens &Toks,
 309                                   bool StopAtSemi, bool ConsumeFinalToken) {
 310   // We always want this function to consume at least one token if the first
 311   // token isn't T and if not at EOF.
 312   bool isFirstTokenConsumed = true;
 313   while (1) {
 314     // If we found one of the tokens, stop and return true.
 315     if (Tok.is(T1) || Tok.is(T2)) {
 316       if (ConsumeFinalToken) {
 317         Toks.push_back(Tok);
 318         ConsumeAnyToken();
 319       }
 320       return true;
 321     }
 322
 323     switch (Tok.getKind()) {
 324     case tok::eof:
 325       // Ran out of tokens.
 326       return false;
 327
 328     case tok::l_paren:
 329       // Recursively consume properly-nested parens.
 330       Toks.push_back(Tok);
 331       ConsumeParen();
 332       ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
 333       break;
 334     case tok::l_square:
 335       // Recursively consume properly-nested square brackets.
 336       Toks.push_back(Tok);
 337       ConsumeBracket();
 338       ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false);
 339       break;
 340     case tok::l_brace:
 341       // Recursively consume properly-nested braces.
 342       Toks.push_back(Tok);
 343       ConsumeBrace();
 344       ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
 345       break;
 346
 347     // Okay, we found a ']' or '}' or ')', which we think should be balanced.
 348     // Since the user wasn't looking for this token (if they were, it would
 349     // already be handled), this isn't balanced.  If there is a LHS token at a
 350     // higher level, we will assume that this matches the unbalanced token
 351     // and return it.  Otherwise, this is a spurious RHS token, which we skip.
 352     case tok::r_paren:
 353       if (ParenCount && !isFirstTokenConsumed)
 354         return false;  // Matches something.
 355       Toks.push_back(Tok);
 356       ConsumeParen();
 357       break;
 358     case tok::r_square:
 359       if (BracketCount && !isFirstTokenConsumed)
 360         return false;  // Matches something.
 361       Toks.push_back(Tok);
 362       ConsumeBracket();
 363       break;
 364     case tok::r_brace:
 365       if (BraceCount && !isFirstTokenConsumed)
 366         return false;  // Matches something.
 367       Toks.push_back(Tok);
 368       ConsumeBrace();
 369       break;
 370
 371     case tok::string_literal:
 372     case tok::wide_string_literal:
 373       Toks.push_back(Tok);
 374       ConsumeStringToken();
 375       break;
 376     case tok::semi:
 377       if (StopAtSemi)
 378         return false;
 379       // FALL THROUGH.
 380     default:
 381       // consume this token.
 382       Toks.push_back(Tok);
 383       ConsumeToken();
 384       break;
 385     }
 386     isFirstTokenConsumed = false;
 387   }
 388 }