CbC/CbC_llvm: clang/lib/Parse/ParseExpr.cpp comparison

comparison clang/lib/Parse/ParseExpr.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	dd44ba33042e c4bab56944e8

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 }
 /// Parse an expr that doesn't include (top-level) commas.
 ExprResult Parser::ParseAssignmentExpression(TypeCastState isTypeCast) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteExpression(getCurScope(),
 PreferredType.get(Tok.getLocation()));
-cutOffParsing();
 return ExprError();
 }
 if (Tok.is(tok::kw_throw))
 return ParseThrowExpression();
 ExprResult Res;
 tok::TokenKind SavedKind = Tok.getKind();
 auto SavedType = PreferredType;
 NotCastExpr = false;
+// Are postfix-expression suffix operators permitted after this
+// cast-expression? If not, and we find some, we'll parse them anyway and
+// diagnose them.
+bool AllowSuffix = true;
 // This handles all of cast-expression, unary-expression, postfix-expression,
 // and primary-expression.  We handle them together like this for efficiency
 // and to simplify handling of an expression starting with a '(' token: which
 // may be one of a parenthesized expression, cast-expression, compound literal
 // expression, or statement expression.
 //
 // If the parsed tokens consist of a primary-expression, the cases below
 // break out of the switch;  at the end we call ParsePostfixExpressionSuffix
 // to handle the postfix expression suffixes.  Cases that cannot be followed
-// by postfix exprs should return without invoking
+// by postfix exprs should set AllowSuffix to false.
-// ParsePostfixExpressionSuffix.
 switch (SavedKind) {
 case tok::l_paren: {
 // If this expression is limited to being a unary-expression, the paren can
 // not start a cast expression.
 ParenParseOption ParenExprType;
 ParsedType CastTy;
 SourceLocation RParenLoc;
 Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/,
 isTypeCast == IsTypeCast, CastTy, RParenLoc);
+// FIXME: What should we do if a vector literal is followed by a
+// postfix-expression suffix? Usually postfix operators are permitted on
+// literals.
 if (isVectorLiteral)
 return Res;
 switch (ParenExprType) {
 case SimpleExpr:   break;    // Nothing else to do.
 case CompoundStmt: break;  // Nothing else to do.
 case CompoundLiteral:
 Res = ParseCXXBoolLiteral();
 break;
 case tok::kw___objc_yes:
 case tok::kw___objc_no:
-return ParseObjCBoolLiteral();
+Res = ParseObjCBoolLiteral();
+break;
 case tok::kw_nullptr:
 Diag(Tok, diag::warn_cxx98_compat_nullptr);
-return Actions.ActOnCXXNullPtrLiteral(ConsumeToken());
+Res = Actions.ActOnCXXNullPtrLiteral(ConsumeToken());
+break;
 case tok::annot_primary_expr:
+case tok::annot_overload_set:
 Res = getExprAnnotation(Tok);
+if (!Res.isInvalid() && Tok.getKind() == tok::annot_overload_set)
+Res = Actions.ActOnNameClassifiedAsOverloadSet(getCurScope(), Res.get());
 ConsumeAnnotationToken();
 if (!Res.isInvalid() && Tok.is(tok::less))
 checkPotentialAngleBracket(Res);
 break;
 // Allow the base to be 'super' if in an objc-method.
 (&II == Ident_super && getCurScope()->isInObjcMethodScope()))) {
 ConsumeToken();
 if (Tok.is(tok::code_completion) && &II != Ident_super) {
+cutOffParsing();
 Actions.CodeCompleteObjCClassPropertyRefExpr(
 getCurScope(), II, ILoc, ExprStatementTokLoc == ILoc);
-cutOffParsing();
 return ExprError();
 }
 // Allow either an identifier or the keyword 'class' (in C++).
 if (Tok.isNot(tok::identifier) &&
 !(getLangOpts().CPlusPlus && Tok.is(tok::kw_class))) {
 const char *PrevSpec = nullptr;
 unsigned DiagID;
 DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ,
 Actions.getASTContext().getPrintingPolicy());
-Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
+Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
 TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
 DeclaratorInfo);
 if (Ty.isInvalid())
 break;
 break;
 case tok::kw__Generic:   // primary-expression: generic-selection [C11 6.5.1]
 Res = ParseGenericSelectionExpression();
 break;
 case tok::kw___builtin_available:
-return ParseAvailabilityCheckExpr(Tok.getLocation());
+Res = ParseAvailabilityCheckExpr(Tok.getLocation());
+break;
 case tok::kw___builtin_va_arg:
 case tok::kw___builtin_offsetof:
 case tok::kw___builtin_choose_expr:
 case tok::kw___builtin_astype: // primary-expression: [OCL] as_type()
 case tok::kw___builtin_convertvector:
 case tok::kw___builtin_FILE:
 case tok::kw___builtin_FUNCTION:
 case tok::kw___builtin_LINE:
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
+// This parses the complete suffix; we can return early.
 return ParseBuiltinPrimaryExpression();
 case tok::kw___null:
-return Actions.ActOnGNUNullExpr(ConsumeToken());
+Res = Actions.ActOnGNUNullExpr(ConsumeToken());
+break;
 case tok::plusplus:      // unary-expression: '++' unary-expression [C99]
 case tok::minusminus: {  // unary-expression: '--' unary-expression [C99]
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
 case tok::kw_vec_step:   // unary-expression: OpenCL 'vec_step' expression
 // unary-expression: '__builtin_omp_required_simd_align' '(' type-name ')'
 case tok::kw___builtin_omp_required_simd_align:
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
-return ParseUnaryExprOrTypeTraitExpression();
+AllowSuffix = false;
+Res = ParseUnaryExprOrTypeTraitExpression();
+break;
 case tok::ampamp: {      // unary-expression: '&&' identifier
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
 SourceLocation AmpAmpLoc = ConsumeToken();
 if (Tok.isNot(tok::identifier))
 Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
 LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
 Tok.getLocation());
 Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), LD);
 ConsumeToken();
-return Res;
+AllowSuffix = false;
+break;
 }
 case tok::kw_const_cast:
 case tok::kw_dynamic_cast:
 case tok::kw_reinterpret_cast:
 case tok::kw_static_cast:
 Res = ParseCXXUuidof();
 break;
 case tok::kw_this:
 Res = ParseCXXThis();
 break;
-case tok::kw___builtin_unique_stable_name:
+case tok::kw___builtin_sycl_unique_stable_name:
-Res = ParseUniqueStableNameExpression();
+Res = ParseSYCLUniqueStableNameExpression();
 break;
 case tok::annot_typename:
 if (isStartOfObjCClassMessageMissingOpenBracket()) {
 TypeResult Type = getTypeAnnotation(Tok);
 // Fake up a Declarator to use with ActOnTypeName.
 unsigned DiagID;
 DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(),
 PrevSpec, DiagID, Type,
 Actions.getASTContext().getPrintingPolicy());
-Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
+Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
 if (Ty.isInvalid())
 break;
 ConsumeAnnotationToken();
 case tok::kw_signed:
 case tok::kw_unsigned:
 case tok::kw_half:
 case tok::kw_float:
 case tok::kw_double:
+case tok::kw___bf16:
 case tok::kw__Float16:
 case tok::kw___float128:
 case tok::kw_void:
 case tok::kw_typename:
 case tok::kw_typeof:
 // ::delete -> [C++] delete-expression
 SourceLocation CCLoc = ConsumeToken();
 if (Tok.is(tok::kw_new)) {
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
-return ParseCXXNewExpression(true, CCLoc);
+Res = ParseCXXNewExpression(true, CCLoc);
+AllowSuffix = false;
+break;
 }
 if (Tok.is(tok::kw_delete)) {
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
-return ParseCXXDeleteExpression(true, CCLoc);
+Res = ParseCXXDeleteExpression(true, CCLoc);
+AllowSuffix = false;
+break;
 }
 // This is not a type name or scope specifier, it is an invalid expression.
 Diag(CCLoc, diag::err_expected_expression);
 return ExprError();
 }
 case tok::kw_new: // [C++] new-expression
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
-return ParseCXXNewExpression(false, Tok.getLocation());
+Res = ParseCXXNewExpression(false, Tok.getLocation());
+AllowSuffix = false;
+break;
 case tok::kw_delete: // [C++] delete-expression
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
-return ParseCXXDeleteExpression(false, Tok.getLocation());
+Res = ParseCXXDeleteExpression(false, Tok.getLocation());
+AllowSuffix = false;
+break;
 case tok::kw_requires: // [C++2a] requires-expression
-return ParseRequiresExpression();
+Res = ParseRequiresExpression();
+AllowSuffix = false;
+break;
 case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
 Diag(Tok, diag::warn_cxx98_compat_noexcept_expr);
 // C++11 [expr.unary.noexcept]p1:
 //   The noexcept operator determines whether the evaluation of its operand,
 //   which is an unevaluated operand, can throw an exception.
 EnterExpressionEvaluationContext Unevaluated(
 Actions, Sema::ExpressionEvaluationContext::Unevaluated);
-ExprResult Result = ParseExpression();
+Res = ParseExpression();
 T.consumeClose();
-if (!Result.isInvalid())
+if (!Res.isInvalid())
-Result = Actions.ActOnNoexceptExpr(KeyLoc, T.getOpenLocation(),
+Res = Actions.ActOnNoexceptExpr(KeyLoc, T.getOpenLocation(), Res.get(),
-Result.get(), T.getCloseLocation());
+T.getCloseLocation());
-return Result;
+AllowSuffix = false;
+break;
 }
 #define TYPE_TRAIT(N,Spelling,K) \
 case tok::kw_##Spelling:
 #include "clang/Basic/TokenKinds.def"
-return ParseTypeTrait();
+Res = ParseTypeTrait();
+break;
 case tok::kw___array_rank:
 case tok::kw___array_extent:
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
-return ParseArrayTypeTrait();
+Res = ParseArrayTypeTrait();
+break;
 case tok::kw___is_lvalue_expr:
 case tok::kw___is_rvalue_expr:
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
-return ParseExpressionTrait();
+Res = ParseExpressionTrait();
+break;
 case tok::at: {
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
 SourceLocation AtLoc = ConsumeToken();
 }
 case tok::caret:
 Res = ParseBlockLiteralExpression();
 break;
 case tok::code_completion: {
+cutOffParsing();
 Actions.CodeCompleteExpression(getCurScope(),
 PreferredType.get(Tok.getLocation()));
-cutOffParsing();
 return ExprError();
 }
 case tok::l_square:
 if (getLangOpts().CPlusPlus11) {
 if (getLangOpts().ObjC) {
 if (ParseKind == PrimaryExprOnly)
 // This is strictly a primary-expression - no postfix-expr pieces should be
 // parsed.
 return Res;
+if (!AllowSuffix) {
+// FIXME: Don't parse a primary-expression suffix if we encountered a parse
+// error already.
+if (Res.isInvalid())
+return Res;
+switch (Tok.getKind()) {
+case tok::l_square:
+case tok::l_paren:
+case tok::plusplus:
+case tok::minusminus:
+// "expected ';'" or similar is probably the right diagnostic here. Let
+// the caller decide what to do.
+if (Tok.isAtStartOfLine())
+return Res;
+LLVM_FALLTHROUGH;
+case tok::period:
+case tok::arrow:
+break;
+default:
+return Res;
+}
+// This was a unary-expression for which a postfix-expression suffix is
+// not permitted by the grammar (eg, a sizeof expression or
+// new-expression or similar). Diagnose but parse the suffix anyway.
+Diag(Tok.getLocation(), diag::err_postfix_after_unary_requires_parens)
+<< Tok.getKind() << Res.get()->getSourceRange()
+<< FixItHint::CreateInsertion(Res.get()->getBeginLoc(), "(")
+<< FixItHint::CreateInsertion(PP.getLocForEndOfToken(PrevTokLocation),
+")");
+}
 // These can be followed by postfix-expr pieces.
 PreferredType = SavedType;
 Res = ParsePostfixExpressionSuffix(Res);
-if (getLangOpts().OpenCL)
+if (getLangOpts().OpenCL &&
+!getActions().getOpenCLOptions().isAvailableOption(
+"__cl_clang_function_pointers", getLangOpts()))
 if (Expr *PostfixExpr = Res.get()) {
 QualType Ty = PostfixExpr->getType();
 if (!Ty.isNull() && Ty->isFunctionType()) {
 Diag(PostfixExpr->getExprLoc(),
 diag::err_opencl_taking_function_address_parser);
 switch (Tok.getKind()) {
 case tok::code_completion:
 if (InMessageExpression)
 return LHS;
+cutOffParsing();
 Actions.CodeCompletePostfixExpression(
 getCurScope(), LHS, PreferredType.get(Tok.getLocation()));
-cutOffParsing();
 return ExprError();
 case tok::identifier:
 // If we see identifier: after an expression, and we're not already in a
 // message send, then this is probably a message send with a missing
 }
 BalancedDelimiterTracker T(*this, tok::l_square);
 T.consumeOpen();
 Loc = T.getOpenLocation();
-ExprResult Idx, Length;
+ExprResult Idx, Length, Stride;
-SourceLocation ColonLoc;
+SourceLocation ColonLocFirst, ColonLocSecond;
 PreferredType.enterSubscript(Actions, Tok.getLocation(), LHS.get());
 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
 Idx = ParseBraceInitializer();
 } else if (getLangOpts().OpenMP) {
 // [ expr
 Idx = ParseExpression();
 }
 if (Tok.is(tok::colon)) {
 // Consume ':'
-ColonLoc = ConsumeToken();
+ColonLocFirst = ConsumeToken();
-if (Tok.isNot(tok::r_square))
+if (Tok.isNot(tok::r_square) &&
+(getLangOpts().OpenMP < 50 ||
+((Tok.isNot(tok::colon) && getLangOpts().OpenMP >= 50))))
 Length = ParseExpression();
+}
+if (getLangOpts().OpenMP >= 50 &&
+(OMPClauseKind == llvm::omp::Clause::OMPC_to ||
+OMPClauseKind == llvm::omp::Clause::OMPC_from) &&
+Tok.is(tok::colon)) {
+// Consume ':'
+ColonLocSecond = ConsumeToken();
+if (Tok.isNot(tok::r_square)) {
+Stride = ParseExpression();
+}
 }
 } else
 Idx = ParseExpression();
 SourceLocation RLoc = Tok.getLocation();
 LHS = Actions.CorrectDelayedTyposInExpr(LHS);
 Idx = Actions.CorrectDelayedTyposInExpr(Idx);
 Length = Actions.CorrectDelayedTyposInExpr(Length);
 if (!LHS.isInvalid() && !Idx.isInvalid() && !Length.isInvalid() &&
-Tok.is(tok::r_square)) {
+!Stride.isInvalid() && Tok.is(tok::r_square)) {
-if (ColonLoc.isValid()) {
+if (ColonLocFirst.isValid() || ColonLocSecond.isValid()) {
-LHS = Actions.ActOnOMPArraySectionExpr(LHS.get(), Loc, Idx.get(),
+LHS = Actions.ActOnOMPArraySectionExpr(
-ColonLoc, Length.get(), RLoc);
+LHS.get(), Loc, Idx.get(), ColonLocFirst, ColonLocSecond,
+Length.get(), Stride.get(), RLoc);
 } else {
 LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.get(), Loc,
 Idx.get(), RLoc);
 }
 } else {
 Expr *CorrectedBase = CorrectedLHS.get();
 if (!CorrectedBase && !getLangOpts().CPlusPlus)
 CorrectedBase = Base;
 // Code completion for a member access expression.
+cutOffParsing();
 Actions.CodeCompleteMemberReferenceExpr(
 getCurScope(), Base, CorrectedBase, OpLoc, OpKind == tok::arrow,
 Base && ExprStatementTokLoc == Base->getBeginLoc(),
 PreferredType.get(Tok.getLocation()));
-cutOffParsing();
 return ExprError();
 }
 if (MayBePseudoDestructor && !LHS.isInvalid()) {
 LHS = ParseCXXPseudoDestructor(LHS.get(), OpLoc, OpKind, SS,
 if (OpTok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof,
 tok::kw__Alignof)) {
 if (isTypeIdUnambiguously()) {
 DeclSpec DS(AttrFactory);
 ParseSpecifierQualifierList(DS);
-Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
+Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
 ParseDeclarator(DeclaratorInfo);
 SourceLocation LParenLoc = PP.getLocForEndOfToken(OpTok.getLocation());
 SourceLocation RParenLoc = PP.getLocForEndOfToken(PrevTokLocation);
-Diag(LParenLoc, diag::err_expected_parentheses_around_typename)
+if (LParenLoc.isInvalid() || RParenLoc.isInvalid()) {
-<< OpTok.getName()
+Diag(OpTok.getLocation(),
-<< FixItHint::CreateInsertion(LParenLoc, "(")
+diag::err_expected_parentheses_around_typename)
-<< FixItHint::CreateInsertion(RParenLoc, ")");
+<< OpTok.getName();
+} else {
+Diag(LParenLoc, diag::err_expected_parentheses_around_typename)
+<< OpTok.getName() << FixItHint::CreateInsertion(LParenLoc, "(")
+<< FixItHint::CreateInsertion(RParenLoc, ")");
+}
 isCastExpr = true;
 return ExprEmpty();
 }
 }
 // If we get here, the operand to the typeof/sizeof/alignof was an expression.
 isCastExpr = false;
 return Operand;
 }
+/// Parse a __builtin_sycl_unique_stable_name expression.  Accepts a type-id as
-ExprResult Parser::ParseUniqueStableNameExpression() {
+/// a parameter.
-assert(Tok.is(tok::kw___builtin_unique_stable_name) &&
+ExprResult Parser::ParseSYCLUniqueStableNameExpression() {
-"Not __bulitin_unique_stable_name");
+assert(Tok.is(tok::kw___builtin_sycl_unique_stable_name) &&
+"Not __bulitin_sycl_unique_stable_name");
 SourceLocation OpLoc = ConsumeToken();
 BalancedDelimiterTracker T(*this, tok::l_paren);
-// typeid expressions are always parenthesized.
+// __builtin_sycl_unique_stable_name expressions are always parenthesized.
 if (T.expectAndConsume(diag::err_expected_lparen_after,
-"__builtin_unique_stable_name"))
+"__builtin_sycl_unique_stable_name"))
 return ExprError();
-if (isTypeIdInParens()) {
+TypeResult Ty = ParseTypeName();
-TypeResult Ty = ParseTypeName();
-T.consumeClose();
+if (Ty.isInvalid()) {
+T.skipToEnd();
-if (Ty.isInvalid())
+return ExprError();
-return ExprError();
+}
-return Actions.ActOnUniqueStableNameExpr(OpLoc, T.getOpenLocation(),
+if (T.consumeClose())
-T.getCloseLocation(), Ty.get());
+return ExprError();
-}
+return Actions.ActOnSYCLUniqueStableNameExpr(OpLoc, T.getOpenLocation(),
-EnterExpressionEvaluationContext Unevaluated(
+T.getCloseLocation(), Ty.get());
-Actions, Sema::ExpressionEvaluationContext::Unevaluated);
-ExprResult Result = ParseExpression();
-if (Result.isInvalid()) {
-SkipUntil(tok::r_paren, StopAtSemi);
-return Result;
-}
-T.consumeClose();
-return Actions.ActOnUniqueStableNameExpr(OpLoc, T.getOpenLocation(),
-T.getCloseLocation(), Result.get());
 }
 /// Parse a sizeof or alignof expression.
 ///
 /// \verbatim
 ExprResult Result(true);
 bool isAmbiguousTypeId;
 CastTy = nullptr;
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteExpression(
 getCurScope(), PreferredType.get(Tok.getLocation()),
 /*IsParenthesized=*/ExprType >= CompoundLiteral);
-cutOffParsing();
 return ExprError();
 }
 // Diagnose use of bridge casts in non-arc mode.
 bool BridgeCast = (getLangOpts().ObjC &&
 // None of these cases should fall through with an invalid Result
 // unless they've already reported an error.
 if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {
 Diag(Tok, diag::ext_gnu_statement_expr);
+checkCompoundToken(OpenLoc, tok::l_paren, CompoundToken::StmtExprBegin);
 if (!getCurScope()->getFnParent() && !getCurScope()->getBlockParent()) {
 Result = ExprError(Diag(OpenLoc, diag::err_stmtexpr_file_scope));
 } else {
 // Find the nearest non-record decl context. Variables declared in a
 }
 // Parse the type declarator.
 DeclSpec DS(AttrFactory);
 ParseSpecifierQualifierList(DS);
-Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
+Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
 ParseDeclarator(DeclaratorInfo);
 // If our type is followed by an identifier and either ':' or ']', then
 // this is probably an Objective-C message send where the leading '[' is
 // missing. Recover as if that were the case.
 SourceLocation LParenLoc,
 SourceLocation RParenLoc) {
 assert(Tok.is(tok::l_brace) && "Not a compound literal!");
 if (!getLangOpts().C99)   // Compound literals don't exist in C90.
 Diag(LParenLoc, diag::ext_c99_compound_literal);
+PreferredType.enterTypeCast(Tok.getLocation(), Ty.get());
 ExprResult Result = ParseInitializer();
 if (!Result.isInvalid() && Ty)
 return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.get());
 return Result;
 }
 Diag(EllipsisLoc, getLangOpts().CPlusPlus17
 ? diag::warn_cxx14_compat_fold_expression
 : diag::ext_fold_expression);
 T.consumeClose();
-return Actions.ActOnCXXFoldExpr(T.getOpenLocation(), LHS.get(), Kind,
+return Actions.ActOnCXXFoldExpr(getCurScope(), T.getOpenLocation(), LHS.get(),
-EllipsisLoc, RHS.get(), T.getCloseLocation());
+Kind, EllipsisLoc, RHS.get(),
+T.getCloseLocation());
 }
 /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
 ///
 /// \verbatim
 /// [clang] block-id:
 /// [clang]   specifier-qualifier-list block-declarator
 /// \endverbatim
 void Parser::ParseBlockId(SourceLocation CaretLoc) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
-return cutOffParsing();
+return;
 }
 // Parse the specifier-qualifier-list piece.
 DeclSpec DS(AttrFactory);
 ParseSpecifierQualifierList(DS);
 // Parse the block-declarator.
-Declarator DeclaratorInfo(DS, DeclaratorContext::BlockLiteralContext);
+Declarator DeclaratorInfo(DS, DeclaratorContext::BlockLiteral);
-DeclaratorInfo.setFunctionDefinitionKind(FDK_Definition);
+DeclaratorInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
 ParseDeclarator(DeclaratorInfo);
 MaybeParseGNUAttributes(DeclaratorInfo);
 // Inform sema that we are starting a block.
 // Inform sema that we are starting a block.
 Actions.ActOnBlockStart(CaretLoc, getCurScope());
 // Parse the return type if present.
 DeclSpec DS(AttrFactory);
-Declarator ParamInfo(DS, DeclaratorContext::BlockLiteralContext);
+Declarator ParamInfo(DS, DeclaratorContext::BlockLiteral);
-ParamInfo.setFunctionDefinitionKind(FDK_Definition);
+ParamInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
 // FIXME: Since the return type isn't actually parsed, it can't be used to
 // fill ParamInfo with an initial valid range, so do it manually.
 ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation()));
 // If this block has arguments, parse them.  There is no ambiguity here with
 if (Tok.is(tok::star)) {
 return AvailabilitySpec(ConsumeToken());
 } else {
 // Parse the platform name.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteAvailabilityPlatformName();
-cutOffParsing();
 return None;
 }
 if (Tok.isNot(tok::identifier)) {
 Diag(Tok, diag::err_avail_query_expected_platform_name);
 return None;

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Parse/ParseExpr.cpp @ 207:2e18cbf3894f