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

comparison clang/lib/Parse/ParseExpr.cpp @ 173:0572611fdcc8 llvm10 llvm12

reorgnization done

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Mon, 25 May 2020 11:55:54 +0900
parents	1d019706d866
children	f935e5e0dbe7 2e18cbf3894f

comparison

equal deleted inserted replaced

-:9fbae9c8bf63
+:0572611fdcc8
 SuggestParentheses(OpToken.getLocation(),
 diag::warn_cxx11_right_shift_in_template_arg,
 SourceRange(Actions.getExprRange(LHS.get()).getBegin(),
 Actions.getExprRange(RHS.get()).getEnd()));
-LHS = Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(),
+ExprResult BinOp =
-OpToken.getKind(), LHS.get(), RHS.get());
+Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(),
+OpToken.getKind(), LHS.get(), RHS.get());
+if (BinOp.isInvalid())
+BinOp = Actions.CreateRecoveryExpr(LHS.get()->getBeginLoc(),
+RHS.get()->getEndLoc(),
+{LHS.get(), RHS.get()});
+LHS = BinOp;
 } else {
-LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc,
+ExprResult CondOp = Actions.ActOnConditionalOp(
-LHS.get(), TernaryMiddle.get(),
+OpToken.getLocation(), ColonLoc, LHS.get(), TernaryMiddle.get(),
 RHS.get());
+if (CondOp.isInvalid()) {
+std::vector<clang::Expr *> Args;
+// TernaryMiddle can be null for the GNU conditional expr extension.
+if (TernaryMiddle.get())
+Args = {LHS.get(), TernaryMiddle.get(), RHS.get()};
+else
+Args = {LHS.get(), RHS.get()};
+CondOp = Actions.CreateRecoveryExpr(LHS.get()->getBeginLoc(),
+RHS.get()->getEndLoc(), Args);
+}
+LHS = CondOp;
 }
 // In this case, ActOnBinOp or ActOnConditionalOp performed the
 // CorrectDelayedTyposInExpr check.
 if (!getLangOpts().CPlusPlus)
 continue;
 if (TryAnnotateTypeOrScopeToken())
 return ExprError();
 assert(Tok.isNot(tok::kw_decltype) && Tok.isNot(tok::kw___super));
 return ParseCastExpression(ParseKind, isAddressOfOperand, isTypeCast,
 isVectorLiteral, NotPrimaryExpression);
 case tok::identifier: {      // primary-expression: identifier
 // unqualified-id: identifier
 // constant: enumeration-constant
 // Turn a potentially qualified name into a annot_typename or
 // annot_cxxscope if it would be valid.  This handles things like x::y, etc.
 // so put the token back where we found it.
 assert(Res.isInvalid());
 UnconsumeToken(SavedTok);
 return ExprError();
 }
-if (!Res.isInvalid())
+if (!Res.isInvalid()) {
+Expr *Arg = Res.get();
 Res = Actions.ActOnUnaryOp(getCurScope(), SavedTok.getLocation(),
-SavedKind, Res.get());
+SavedKind, Arg);
+if (Res.isInvalid())
+Res = Actions.CreateRecoveryExpr(SavedTok.getLocation(),
+Arg->getEndLoc(), Arg);
+}
 return Res;
 }
 case tok::amp: {         // unary-expression: '&' cast-expression
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
 // Special treatment because of member pointers
 SourceLocation SavedLoc = ConsumeToken();
 PreferredType.enterUnary(Actions, Tok.getLocation(), tok::amp, SavedLoc);
 Res = ParseCastExpression(AnyCastExpr, true);
-if (!Res.isInvalid())
+if (!Res.isInvalid()) {
-Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
+Expr *Arg = Res.get();
+Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Arg);
+if (Res.isInvalid())
+Res = Actions.CreateRecoveryExpr(Tok.getLocation(), Arg->getEndLoc(),
+Arg);
+}
 return Res;
 }
 case tok::star:          // unary-expression: '*' cast-expression
 case tok::plus:          // unary-expression: '+' cast-expression
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
 SourceLocation SavedLoc = ConsumeToken();
 PreferredType.enterUnary(Actions, Tok.getLocation(), SavedKind, SavedLoc);
 Res = ParseCastExpression(AnyCastExpr);
-if (!Res.isInvalid())
+if (!Res.isInvalid()) {
-Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
+Expr *Arg = Res.get();
+Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Arg);
+if (Res.isInvalid())
+Res = Actions.CreateRecoveryExpr(SavedLoc, Arg->getEndLoc(), Arg);
+}
 return Res;
 }
 case tok::kw_co_await: {  // unary-expression: 'co_await' cast-expression
 if (NotPrimaryExpression)
 }
 case tok::kw_const_cast:
 case tok::kw_dynamic_cast:
 case tok::kw_reinterpret_cast:
 case tok::kw_static_cast:
+case tok::kw_addrspace_cast:
 if (NotPrimaryExpression)
 *NotPrimaryExpression = true;
 Res = ParseCXXCasts();
 break;
 case tok::kw___builtin_bit_cast:
 Res = ParseCXXUuidof();
 break;
 case tok::kw_this:
 Res = ParseCXXThis();
 break;
+case tok::kw___builtin_unique_stable_name:
+Res = ParseUniqueStableNameExpression();
+break;
 case tok::annot_typename:
 if (isStartOfObjCClassMessageMissingOpenBracket()) {
-ParsedType Type = getTypeAnnotation(Tok);
+TypeResult Type = getTypeAnnotation(Tok);
 // Fake up a Declarator to use with ActOnTypeName.
 DeclSpec DS(AttrFactory);
 DS.SetRangeStart(Tok.getLocation());
 DS.SetRangeEnd(Tok.getLastLoc());
 case tok::kw_short:
 case tok::kw_int:
 case tok::kw_long:
 case tok::kw___int64:
 case tok::kw___int128:
+case tok::kw__ExtInt:
 case tok::kw_signed:
 case tok::kw_unsigned:
 case tok::kw_half:
 case tok::kw_float:
 case tok::kw_double:
 if (TemplateId->Kind == TNK_Type_template) {
 // We have a qualified template-id that we know refers to a
 // type, translate it into a type and continue parsing as a
 // cast expression.
 CXXScopeSpec SS;
-ParseOptionalCXXScopeSpecifier(SS, nullptr,
+ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
+/*ObjectHadErrors=*/false,
 /*EnteringContext=*/false);
 AnnotateTemplateIdTokenAsType(SS);
 return ParseCastExpression(ParseKind, isAddressOfOperand, NotCastExpr,
 isTypeCast, isVectorLiteral,
 NotPrimaryExpression);
 SkipUntil(tok::r_paren, StopAtSemi);
 else
 PT.consumeClose();
 LHS = ExprError();
 } else {
-assert((ArgExprs.size() == 0 ||
+assert(
-ArgExprs.size()-1 == CommaLocs.size())&&
+(ArgExprs.size() == 0 || ArgExprs.size() - 1 == CommaLocs.size()) &&
 "Unexpected number of commas!");
-LHS = Actions.ActOnCallExpr(getCurScope(), LHS.get(), Loc,
+Expr *Fn = LHS.get();
-ArgExprs, Tok.getLocation(),
+SourceLocation RParLoc = Tok.getLocation();
+LHS = Actions.ActOnCallExpr(getCurScope(), Fn, Loc, ArgExprs, RParLoc,
 ExecConfig);
+if (LHS.isInvalid()) {
+ArgExprs.insert(ArgExprs.begin(), Fn);
+LHS =
+Actions.CreateRecoveryExpr(Fn->getBeginLoc(), RParLoc, ArgExprs);
+}
 PT.consumeClose();
 }
 break;
 }
 << OpKind << Base->getSourceRange()
 << FixItHint::CreateRemoval(OpLoc);
 return ParsePostfixExpressionSuffix(Base);
 }
-LHS = Actions.ActOnStartCXXMemberReference(getCurScope(), Base,
+LHS = Actions.ActOnStartCXXMemberReference(getCurScope(), Base, OpLoc,
-OpLoc, OpKind, ObjectType,
+OpKind, ObjectType,
 MayBePseudoDestructor);
-if (LHS.isInvalid())
+if (LHS.isInvalid()) {
+// Clang will try to perform expression based completion as a
+// fallback, which is confusing in case of member references. So we
+// stop here without any completions.
+if (Tok.is(tok::code_completion)) {
+cutOffParsing();
+return ExprError();
+}
 break;
+}
-ParseOptionalCXXScopeSpecifier(SS, ObjectType,
+ParseOptionalCXXScopeSpecifier(
-/*EnteringContext=*/false,
+SS, ObjectType, LHS.get() && LHS.get()->containsErrors(),
-&MayBePseudoDestructor);
+/*EnteringContext=*/false, &MayBePseudoDestructor);
 if (SS.isNotEmpty())
 ObjectType = nullptr;
 }
 if (Tok.is(tok::code_completion)) {
 // such a common method name. For other C++ keywords that are
 // Objective-C method names, one must use the message send syntax.
 IdentifierInfo *Id = Tok.getIdentifierInfo();
 SourceLocation Loc = ConsumeToken();
 Name.setIdentifier(Id, Loc);
-} else if (ParseUnqualifiedId(SS,
+} else if (ParseUnqualifiedId(
-/*EnteringContext=*/false,
+SS, ObjectType, LHS.get() && LHS.get()->containsErrors(),
-/*AllowDestructorName=*/true,
+/*EnteringContext=*/false,
-/*AllowConstructorName=*/
+/*AllowDestructorName=*/true,
-getLangOpts().MicrosoftExt &&
+/*AllowConstructorName=*/
-SS.isNotEmpty(),
+getLangOpts().MicrosoftExt && SS.isNotEmpty(),
-/*AllowDeductionGuide=*/false,
+/*AllowDeductionGuide=*/false, &TemplateKWLoc, Name)) {
-ObjectType, &TemplateKWLoc, Name)) {
 (void)Actions.CorrectDelayedTyposInExpr(LHS);
 LHS = ExprError();
 }
 if (!LHS.isInvalid())
 LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.get(), OpLoc,
 OpKind, SS, TemplateKWLoc, Name,
 CurParsedObjCImpl ? CurParsedObjCImpl->Dcl
 : nullptr);
-if (!LHS.isInvalid() && Tok.is(tok::less))
+if (!LHS.isInvalid()) {
-checkPotentialAngleBracket(LHS);
+if (Tok.is(tok::less))
+checkPotentialAngleBracket(LHS);
+} else if (OrigLHS && Name.isValid()) {
+// Preserve the LHS if the RHS is an invalid member.
+LHS = Actions.CreateRecoveryExpr(OrigLHS->getBeginLoc(),
+Name.getEndLoc(), {OrigLHS});
+}
 break;
 }
 case tok::plusplus:    // postfix-expression: postfix-expression '++'
 case tok::minusminus:  // postfix-expression: postfix-expression '--'
 if (!LHS.isInvalid()) {
+Expr *Arg = LHS.get();
 LHS = Actions.ActOnPostfixUnaryOp(getCurScope(), Tok.getLocation(),
-Tok.getKind(), LHS.get());
+Tok.getKind(), Arg);
+if (LHS.isInvalid())
+LHS = Actions.CreateRecoveryExpr(Arg->getBeginLoc(),
+Tok.getLocation(), Arg);
 }
 ConsumeToken();
 break;
 }
 }
 // If we get here, the operand to the typeof/sizeof/alignof was an expression.
 isCastExpr = false;
 return Operand;
 }
+ExprResult Parser::ParseUniqueStableNameExpression() {
+assert(Tok.is(tok::kw___builtin_unique_stable_name) &&
+"Not __bulitin_unique_stable_name");
+SourceLocation OpLoc = ConsumeToken();
+BalancedDelimiterTracker T(*this, tok::l_paren);
+// typeid expressions are always parenthesized.
+if (T.expectAndConsume(diag::err_expected_lparen_after,
+"__builtin_unique_stable_name"))
+return ExprError();
+if (isTypeIdInParens()) {
+TypeResult Ty = ParseTypeName();
+T.consumeClose();
+if (Ty.isInvalid())
+return ExprError();
+return Actions.ActOnUniqueStableNameExpr(OpLoc, T.getOpenLocation(),
+T.getCloseLocation(), Ty.get());
+}
+EnterExpressionEvaluationContext Unevaluated(
+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
 ///       unary-expression:  [C99 6.5.3]
 // These can be followed by postfix-expr pieces because they are
 // primary-expressions.
 return ParsePostfixExpressionSuffix(Res.get());
 }
+bool Parser::tryParseOpenMPArrayShapingCastPart() {
+assert(Tok.is(tok::l_square) && "Expected open bracket");
+bool ErrorFound = true;
+TentativeParsingAction TPA(*this);
+do {
+if (Tok.isNot(tok::l_square))
+break;
+// Consume '['
+ConsumeBracket();
+// Skip inner expression.
+while (!SkipUntil(tok::r_square, tok::annot_pragma_openmp_end,
+StopAtSemi | StopBeforeMatch))
+;
+if (Tok.isNot(tok::r_square))
+break;
+// Consume ']'
+ConsumeBracket();
+// Found ')' - done.
+if (Tok.is(tok::r_paren)) {
+ErrorFound = false;
+break;
+}
+} while (Tok.isNot(tok::annot_pragma_openmp_end));
+TPA.Revert();
+return !ErrorFound;
+}
 /// ParseParenExpression - This parses the unit that starts with a '(' token,
 /// based on what is allowed by ExprType.  The actual thing parsed is returned
 /// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,
 /// not the parsed cast-expression.
 ///
 ///       fold-expression: [C++1z]
 ///         '(' cast-expression fold-operator '...' ')'
 ///         '(' '...' fold-operator cast-expression ')'
 ///         '(' cast-expression fold-operator '...'
 ///                 fold-operator cast-expression ')'
+/// [OPENMP] Array shaping operation
+///       '(' '[' expression ']' { '[' expression ']' } cast-expression
 /// \endverbatim
 ExprResult
 Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
 bool isTypeCast, ParsedType &CastTy,
 SourceLocation &RParenLoc) {
 StmtResult Stmt(ParseCompoundStatement(true));
 ExprType = CompoundStmt;
 // If the substmt parsed correctly, build the AST node.
 if (!Stmt.isInvalid()) {
-Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.get(), Tok.getLocation());
+Result = Actions.ActOnStmtExpr(getCurScope(), OpenLoc, Stmt.get(),
+Tok.getLocation());
 } else {
 Actions.ActOnStmtExprError();
 }
 }
 } else if (ExprType >= CompoundLiteral && BridgeCast) {
 ColonProtection.restore();
 RParenLoc = T.getCloseLocation();
 PreferredType.enterTypeCast(Tok.getLocation(), Ty.get().get());
 ExprResult SubExpr = ParseCastExpression(AnyCastExpr);
 if (Ty.isInvalid() || SubExpr.isInvalid())
 return ExprError();
 return Actions.ActOnObjCBridgedCast(getCurScope(), OpenLoc, Kind,
 BridgeKeywordLoc, Ty.get(),
 ExprType = SimpleExpr;
 Result = Actions.ActOnParenListExpr(OpenLoc, Tok.getLocation(),
 ArgExprs);
 }
+} else if (getLangOpts().OpenMP >= 50 && OpenMPDirectiveParsing &&
+ExprType == CastExpr && Tok.is(tok::l_square) &&
+tryParseOpenMPArrayShapingCastPart()) {
+bool ErrorFound = false;
+SmallVector<Expr *, 4> OMPDimensions;
+SmallVector<SourceRange, 4> OMPBracketsRanges;
+do {
+BalancedDelimiterTracker TS(*this, tok::l_square);
+TS.consumeOpen();
+ExprResult NumElements =
+Actions.CorrectDelayedTyposInExpr(ParseExpression());
+if (!NumElements.isUsable()) {
+ErrorFound = true;
+while (!SkipUntil(tok::r_square, tok::r_paren,
+StopAtSemi | StopBeforeMatch))
+;
+}
+TS.consumeClose();
+OMPDimensions.push_back(NumElements.get());
+OMPBracketsRanges.push_back(TS.getRange());
+} while (Tok.isNot(tok::r_paren));
+// Match the ')'.
+T.consumeClose();
+RParenLoc = T.getCloseLocation();
+Result = Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
+if (ErrorFound) {
+Result = ExprError();
+} else if (!Result.isInvalid()) {
+Result = Actions.ActOnOMPArrayShapingExpr(
+Result.get(), OpenLoc, RParenLoc, OMPDimensions, OMPBracketsRanges);
+}
+return Result;
 } else {
 InMessageExpressionRAIIObject InMessage(*this, false);
 Result = ParseExpression(MaybeTypeCast);
 if (!getLangOpts().CPlusPlus && MaybeTypeCast && Result.isUsable()) {

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Parse/ParseExpr.cpp @ 173:0572611fdcc8 llvm10 llvm12