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

comparison clang/lib/Parse/ParseObjc.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	c4bab56944e8

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 Parser::DeclGroupPtrTy
 Parser::ParseObjCAtDirectives(ParsedAttributesWithRange &Attrs) {
 SourceLocation AtLoc = ConsumeToken(); // the "@"
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCAtDirective(getCurScope());
-cutOffParsing();
 return nullptr;
 }
 Decl *SingleDecl = nullptr;
 switch (Tok.getObjCKeywordID()) {
 CheckNestedObjCContexts(AtLoc);
 ConsumeToken(); // the "interface" identifier
 // Code completion after '@interface'.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCInterfaceDecl(getCurScope());
-cutOffParsing();
 return nullptr;
 }
 MaybeSkipAttributes(tok::objc_interface);
 T.consumeOpen();
 SourceLocation categoryLoc;
 IdentifierInfo *categoryId = nullptr;
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc);
-cutOffParsing();
 return nullptr;
 }
 // For ObjC2, the category name is optional (not an error).
 if (Tok.is(tok::identifier)) {
 if (Tok.is(tok::colon)) { // a super class is specified.
 ConsumeToken();
 // Code completion of superclass names.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc);
-cutOffParsing();
 return nullptr;
 }
 if (expectIdentifier())
 return nullptr; // missing super class name.
 if (!Tok.is(tok::identifier)) {
 // Code completion.
 if (Tok.is(tok::code_completion)) {
 // FIXME: If these aren't protocol references, we'll need different
 // completions.
+cutOffParsing();
 Actions.CodeCompleteObjCProtocolReferences(protocolIdents);
-cutOffParsing();
 // FIXME: Better recovery here?.
 return nullptr;
 }
 if (isEofOrEom())
 break;
 // Code completion within an Objective-C interface.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteOrdinaryName(getCurScope(),
 CurParsedObjCImpl? Sema::PCC_ObjCImplementation
 : Sema::PCC_ObjCInterface);
-return cutOffParsing();
+return;
 }
 // If we don't have an @ directive, parse it as a function definition.
 if (Tok.isNot(tok::at)) {
 // The code below does not consume '}'s because it is afraid of eating the
 // ParseExternalDeclaration() below (so that this doesn't parse nested
 // @interfaces), this needs to duplicate some code from the latter.
 if (Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) {
 SourceLocation DeclEnd;
 allTUVariables.push_back(
-ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs));
+ParseDeclaration(DeclaratorContext::File, DeclEnd, attrs));
 continue;
 }
 allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs));
 continue;
 }
 // Otherwise, we have an @ directive, eat the @.
 SourceLocation AtLoc = ConsumeToken(); // the "@"
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCAtDirective(getCurScope());
-return cutOffParsing();
+return;
 }
 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID();
 if (DirectiveKind == tok::objc_end) { // @end -> terminate list
 }
 // We break out of the big loop in two cases: when we see @end or when we see
 // EOF.  In the former case, eat the @end.  In the later case, emit an error.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCAtDirective(getCurScope());
-return cutOffParsing();
+return;
 } else if (Tok.isObjCAtKeyword(tok::objc_end)) {
 ConsumeToken(); // the "end" identifier
 } else {
 Diag(Tok, diag::err_objc_missing_end)
 << FixItHint::CreateInsertion(Tok.getLocation(), "\n@end\n");
 BalancedDelimiterTracker T(*this, tok::l_paren);
 T.consumeOpen();
 while (1) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS);
-return cutOffParsing();
+return;
 }
 const IdentifierInfo *II = Tok.getIdentifierInfo();
 // If this is not an identifier at all, bail out early.
 if (!II) {
 SkipUntil(tok::r_paren, StopAtSemi);
 return;
 }
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 if (IsSetter)
 Actions.CodeCompleteObjCPropertySetter(getCurScope());
 else
 Actions.CodeCompleteObjCPropertyGetter(getCurScope());
-return cutOffParsing();
+return;
 }
 SourceLocation SelLoc;
 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc);
 ///     'nullable'
 ///     'null_unspecified'
 ///
 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS,
 DeclaratorContext Context) {
-assert(Context == DeclaratorContext::ObjCParameterContext ||
+assert(Context == DeclaratorContext::ObjCParameter ||
-Context == DeclaratorContext::ObjCResultContext);
+Context == DeclaratorContext::ObjCResult);
 while (1) {
 if (Tok.is(tok::code_completion)) {
-Actions.CodeCompleteObjCPassingType(getCurScope(), DS,
+cutOffParsing();
-Context == DeclaratorContext::ObjCParameterContext);
+Actions.CodeCompleteObjCPassingType(
-return cutOffParsing();
+getCurScope(), DS, Context == DeclaratorContext::ObjCParameter);
+return;
 }
 if (Tok.isNot(tok::identifier))
 return;
 ///     '(' objc-type-qualifiers[opt] ')'
 ///
 ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS,
 DeclaratorContext context,
 ParsedAttributes *paramAttrs) {
-assert(context == DeclaratorContext::ObjCParameterContext ||
+assert(context == DeclaratorContext::ObjCParameter ||
-context == DeclaratorContext::ObjCResultContext);
+context == DeclaratorContext::ObjCResult);
 assert((paramAttrs != nullptr) ==
-(context == DeclaratorContext::ObjCParameterContext));
+(context == DeclaratorContext::ObjCParameter));
 assert(Tok.is(tok::l_paren) && "expected (");
 BalancedDelimiterTracker T(*this, tok::l_paren);
 T.consumeOpen();
 if (isTypeSpecifierQualifier() || isObjCInstancetype()) {
 // Parse an abstract declarator.
 DeclSpec declSpec(AttrFactory);
 declSpec.setObjCQualifiers(&DS);
 DeclSpecContext dsContext = DeclSpecContext::DSC_normal;
-if (context == DeclaratorContext::ObjCResultContext)
+if (context == DeclaratorContext::ObjCResult)
 dsContext = DeclSpecContext::DSC_objc_method_result;
 ParseSpecifierQualifierList(declSpec, AS_none, dsContext);
 Declarator declarator(declSpec, context);
 ParseDeclarator(declarator);
 if (!type.isInvalid())
 Ty = type.get();
 // If we're parsing a parameter, steal all the decl attributes
 // and add them to the decl spec.
-if (context == DeclaratorContext::ObjCParameterContext)
+if (context == DeclaratorContext::ObjCParameter)
 takeDeclAttributes(*paramAttrs, declarator);
 }
 }
 if (Tok.is(tok::r_paren))
 tok::ObjCKeywordKind MethodImplKind,
 bool MethodDefinition) {
 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
 /*ReturnType=*/nullptr);
-cutOffParsing();
 return nullptr;
 }
 // Parse the return type if present.
 ParsedType ReturnType;
 ObjCDeclSpec DSRet;
 if (Tok.is(tok::l_paren))
-ReturnType = ParseObjCTypeName(DSRet, DeclaratorContext::ObjCResultContext,
+ReturnType =
-nullptr);
+ParseObjCTypeName(DSRet, DeclaratorContext::ObjCResult, nullptr);
 // If attributes exist before the method, parse them.
 ParsedAttributes methodAttrs(AttrFactory);
-if (getLangOpts().ObjC)
+MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-MaybeParseGNUAttributes(methodAttrs);
+methodAttrs);
-MaybeParseCXX11Attributes(methodAttrs);
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
 ReturnType);
-cutOffParsing();
 return nullptr;
 }
 // Now parse the selector.
 SourceLocation selLoc;
 }
 SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo;
 if (Tok.isNot(tok::colon)) {
 // If attributes exist after the method, parse them.
-if (getLangOpts().ObjC)
+MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-MaybeParseGNUAttributes(methodAttrs);
+methodAttrs);
-MaybeParseCXX11Attributes(methodAttrs);
 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent);
 Decl *Result = Actions.ActOnMethodDeclaration(
 getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType,
 selLoc, Sel, nullptr, CParamInfo.data(), CParamInfo.size(), methodAttrs,
 if (ExpectAndConsume(tok::colon))
 break;
 ArgInfo.Type = nullptr;
 if (Tok.is(tok::l_paren)) // Parse the argument type if present.
-ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec,
+ArgInfo.Type = ParseObjCTypeName(
-DeclaratorContext::ObjCParameterContext,
+ArgInfo.DeclSpec, DeclaratorContext::ObjCParameter, &paramAttrs);
-&paramAttrs);
 // If attributes exist before the argument name, parse them.
 // Regardless, collect all the attributes we've parsed so far.
-if (getLangOpts().ObjC)
+MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-MaybeParseGNUAttributes(paramAttrs);
+paramAttrs);
-MaybeParseCXX11Attributes(paramAttrs);
 ArgInfo.ArgAttrs = paramAttrs;
 // Code completion for the next piece of the selector.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 KeyIdents.push_back(SelIdent);
 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
 mType == tok::minus,
 /*AtParameterName=*/true,
 ReturnType, KeyIdents);
-cutOffParsing();
 return nullptr;
 }
 if (expectIdentifier())
 break; // missing argument name.
 // Make sure the attributes persist.
 allParamAttrs.takeAllFrom(paramAttrs.getPool());
 // Code completion for the next piece of the selector.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
 mType == tok::minus,
 /*AtParameterName=*/false,
 ReturnType, KeyIdents);
-cutOffParsing();
 return nullptr;
 }
 // Check for another keyword selector.
 SelIdent = ParseObjCSelectorPiece(selLoc);
 cStyleParamWarned = true;
 }
 DeclSpec DS(AttrFactory);
 ParseDeclarationSpecifiers(DS);
 // Parse the declarator.
-Declarator ParmDecl(DS, DeclaratorContext::PrototypeContext);
+Declarator ParmDecl(DS, DeclaratorContext::Prototype);
 ParseDeclarator(ParmDecl);
 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
 CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
 ParmDecl.getIdentifierLoc(),
 nullptr));
 }
 // FIXME: Add support for optional parameter list...
 // If attributes exist after the method, parse them.
-if (getLangOpts().ObjC)
+MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-MaybeParseGNUAttributes(methodAttrs);
+methodAttrs);
-MaybeParseCXX11Attributes(methodAttrs);
 if (KeyIdents.size() == 0)
 return nullptr;
 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(),
 SmallVector<IdentifierLocPair, 8> ProtocolIdents;
 while (1) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents);
-cutOffParsing();
 return true;
 }
 if (expectIdentifier()) {
 SkipUntil(tok::greater, StopAtSemi);
 identifierLocPairs.push_back(IdentifierLocPair(identifiers[i],
 identifierLocs[i]));
 }
 QualType BaseT = Actions.GetTypeFromParser(baseType);
+cutOffParsing();
 if (!BaseT.isNull() && BaseT->acceptsObjCTypeParams()) {
 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
 } else {
 Actions.CodeCompleteObjCProtocolReferences(identifierLocPairs);
 }
-cutOffParsing();
 return;
 }
 allSingleIdentifiers = false;
 break;
 unsigned diagID;
 DS.SetTypeSpecType(TST_typename, identifierLocs[i], prevSpec, diagID,
 typeArg, Actions.getASTContext().getPrintingPolicy());
 // Form a declarator to turn this into a type.
-Declarator D(DS, DeclaratorContext::TypeNameContext);
+Declarator D(DS, DeclaratorContext::TypeName);
 TypeResult fullTypeArg = Actions.ActOnTypeName(getCurScope(), D);
 if (fullTypeArg.isUsable()) {
 typeArgs.push_back(fullTypeArg.get());
 if (!foundValidTypeId) {
 foundValidTypeId = identifiers[i];
 }
 // Set the default visibility to private.
 if (TryConsumeToken(tok::at)) { // parse objc-visibility-spec
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCAtVisibility(getCurScope());
-return cutOffParsing();
+return;
 }
 switch (Tok.getObjCKeywordID()) {
 case tok::objc_private:
 case tok::objc_public:
 continue;
 }
 }
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteOrdinaryName(getCurScope(),
 Sema::PCC_ObjCInstanceVariableList);
-return cutOffParsing();
+return;
 }
 // This needs to duplicate a small amount of code from
 // ParseStructUnionBody() for things that should work in both
 // C struct and in Objective-C class instance variables.
 assert(Tok.isObjCAtKeyword(tok::objc_protocol) &&
 "ParseObjCAtProtocolDeclaration(): Expected @protocol");
 ConsumeToken(); // the "protocol" identifier
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCProtocolDecl(getCurScope());
-cutOffParsing();
 return nullptr;
 }
 MaybeSkipAttributes(tok::objc_protocol);
 CheckNestedObjCContexts(AtLoc);
 ConsumeToken(); // the "implementation" identifier
 // Code completion after '@implementation'.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCImplementationDecl(getCurScope());
-cutOffParsing();
 return nullptr;
 }
 MaybeSkipAttributes(tok::objc_implementation);
 ConsumeParen();
 SourceLocation categoryLoc, rparenLoc;
 IdentifierInfo *categoryId = nullptr;
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc);
-cutOffParsing();
 return nullptr;
 }
 if (Tok.is(tok::identifier)) {
 categoryId = Tok.getIdentifierInfo();
 "ParseObjCPropertySynthesize(): Expected '@synthesize'");
 ConsumeToken(); // consume synthesize
 while (true) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCPropertyDefinition(getCurScope());
-cutOffParsing();
 return nullptr;
 }
 if (Tok.isNot(tok::identifier)) {
 Diag(Tok, diag::err_synthesized_property_name);
 SourceLocation propertyLoc = ConsumeToken(); // consume property name
 SourceLocation propertyIvarLoc;
 if (TryConsumeToken(tok::equal)) {
 // property '=' ivar-name
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId);
-cutOffParsing();
 return nullptr;
 }
 if (expectIdentifier())
 break;
 }
 }
 while (true) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCPropertyDefinition(getCurScope());
-cutOffParsing();
 return nullptr;
 }
 if (expectIdentifier()) {
 SkipUntil(tok::semi);
 Scope::CompoundStmtScope |
 Scope::AtCatchScope);
 if (Tok.isNot(tok::ellipsis)) {
 DeclSpec DS(AttrFactory);
 ParseDeclarationSpecifiers(DS);
-Declarator ParmDecl(DS, DeclaratorContext::ObjCCatchContext);
+Declarator ParmDecl(DS, DeclaratorContext::ObjCCatch);
 ParseDeclarator(ParmDecl);
 // Inform the actions module about the declarator, so it
 // gets added to the current scope.
 FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl);
 }
 StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc,
 ParsedStmtContext StmtCtx) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCAtStatement(getCurScope());
-cutOffParsing();
 return StmtError();
 }
 if (Tok.isObjCAtKeyword(tok::objc_try))
 return ParseObjCTryStmt(AtLoc);
 }
 ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {
 switch (Tok.getKind()) {
 case tok::code_completion:
+cutOffParsing();
 Actions.CodeCompleteObjCAtExpression(getCurScope());
-cutOffParsing();
 return ExprError();
 case tok::minus:
 case tok::plus: {
 tok::TokenKind Kind = Tok.getKind();
 }
 // We have a class message. Turn the simple-type-specifier or
 // typename-specifier we parsed into a type and parse the
 // remainder of the class message.
-Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
+Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
 TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
 if (Type.isInvalid())
 return true;
 IsExpr = false;
 ExprResult Parser::ParseObjCMessageExpression() {
 assert(Tok.is(tok::l_square) && "'[' expected");
 SourceLocation LBracLoc = ConsumeBracket(); // consume '['
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
-cutOffParsing();
 return ExprError();
 }
 InMessageExpressionRAIIObject InMessage(*this, true);
 ParsedType ReceiverType,
 Expr *ReceiverExpr) {
 InMessageExpressionRAIIObject InMessage(*this, true);
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 if (SuperLoc.isValid())
 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, None,
 false);
 else if (ReceiverType)
 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, None,
 false);
 else
 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
 None, false);
-cutOffParsing();
 return ExprError();
 }
 // Parse objc-selector
 SourceLocation Loc;
 }
 ///  Parse the expression after ':'
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 if (SuperLoc.isValid())
 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
 KeyIdents,
 /*AtArgumentExpression=*/true);
 else if (ReceiverType)
 else
 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
 KeyIdents,
 /*AtArgumentExpression=*/true);
-cutOffParsing();
 return ExprError();
 }
 ExprResult Expr;
 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
 // We have a valid expression.
 KeyExprs.push_back(Res.get());
 // Code completion after each argument.
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 if (SuperLoc.isValid())
 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
 KeyIdents,
 /*AtArgumentExpression=*/false);
 else if (ReceiverType)
 /*AtArgumentExpression=*/false);
 else
 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
 KeyIdents,
 /*AtArgumentExpression=*/false);
-cutOffParsing();
 return ExprError();
 }
 // Check for another keyword selector.
 selIdent = ParseObjCSelectorPiece(Loc);
 bool HasOptionalParen = Tok.is(tok::l_paren);
 if (HasOptionalParen)
 ConsumeParen();
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents);
-cutOffParsing();
 return ExprError();
 }
 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc);
 if (!SelIdent &&  // missing selector name.
 if (Tok.is(tok::r_paren))
 break;
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents);
-cutOffParsing();
 return ExprError();
 }
 // Check for another keyword selector.
 SourceLocation Loc;

Mercurial > hg > CbC > CbC_llvm

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