forked from OSchip/llvm-project
1939 lines
63 KiB
C++
1939 lines
63 KiB
C++
//===--- ParseTentative.cpp - Ambiguity Resolution Parsing ----------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the tentative parsing portions of the Parser
|
|
// interfaces, for ambiguity resolution.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Parse/Parser.h"
|
|
#include "clang/Parse/ParseDiagnostic.h"
|
|
#include "clang/Sema/ParsedTemplate.h"
|
|
using namespace clang;
|
|
|
|
/// isCXXDeclarationStatement - C++-specialized function that disambiguates
|
|
/// between a declaration or an expression statement, when parsing function
|
|
/// bodies. Returns true for declaration, false for expression.
|
|
///
|
|
/// declaration-statement:
|
|
/// block-declaration
|
|
///
|
|
/// block-declaration:
|
|
/// simple-declaration
|
|
/// asm-definition
|
|
/// namespace-alias-definition
|
|
/// using-declaration
|
|
/// using-directive
|
|
/// [C++0x] static_assert-declaration
|
|
///
|
|
/// asm-definition:
|
|
/// 'asm' '(' string-literal ')' ';'
|
|
///
|
|
/// namespace-alias-definition:
|
|
/// 'namespace' identifier = qualified-namespace-specifier ';'
|
|
///
|
|
/// using-declaration:
|
|
/// 'using' typename[opt] '::'[opt] nested-name-specifier
|
|
/// unqualified-id ';'
|
|
/// 'using' '::' unqualified-id ;
|
|
///
|
|
/// using-directive:
|
|
/// 'using' 'namespace' '::'[opt] nested-name-specifier[opt]
|
|
/// namespace-name ';'
|
|
///
|
|
bool Parser::isCXXDeclarationStatement() {
|
|
switch (Tok.getKind()) {
|
|
// asm-definition
|
|
case tok::kw_asm:
|
|
// namespace-alias-definition
|
|
case tok::kw_namespace:
|
|
// using-declaration
|
|
// using-directive
|
|
case tok::kw_using:
|
|
// static_assert-declaration
|
|
case tok::kw_static_assert:
|
|
case tok::kw__Static_assert:
|
|
return true;
|
|
// simple-declaration
|
|
default:
|
|
return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/false);
|
|
}
|
|
}
|
|
|
|
/// isCXXSimpleDeclaration - C++-specialized function that disambiguates
|
|
/// between a simple-declaration or an expression-statement.
|
|
/// If during the disambiguation process a parsing error is encountered,
|
|
/// the function returns true to let the declaration parsing code handle it.
|
|
/// Returns false if the statement is disambiguated as expression.
|
|
///
|
|
/// simple-declaration:
|
|
/// decl-specifier-seq init-declarator-list[opt] ';'
|
|
/// decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
|
|
/// brace-or-equal-initializer ';' [C++17]
|
|
///
|
|
/// (if AllowForRangeDecl specified)
|
|
/// for ( for-range-declaration : for-range-initializer ) statement
|
|
///
|
|
/// for-range-declaration:
|
|
/// decl-specifier-seq declarator
|
|
/// decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
|
|
///
|
|
/// In any of the above cases there can be a preceding attribute-specifier-seq,
|
|
/// but the caller is expected to handle that.
|
|
bool Parser::isCXXSimpleDeclaration(bool AllowForRangeDecl) {
|
|
// C++ 6.8p1:
|
|
// There is an ambiguity in the grammar involving expression-statements and
|
|
// declarations: An expression-statement with a function-style explicit type
|
|
// conversion (5.2.3) as its leftmost subexpression can be indistinguishable
|
|
// from a declaration where the first declarator starts with a '('. In those
|
|
// cases the statement is a declaration. [Note: To disambiguate, the whole
|
|
// statement might have to be examined to determine if it is an
|
|
// expression-statement or a declaration].
|
|
|
|
// C++ 6.8p3:
|
|
// The disambiguation is purely syntactic; that is, the meaning of the names
|
|
// occurring in such a statement, beyond whether they are type-names or not,
|
|
// is not generally used in or changed by the disambiguation. Class
|
|
// templates are instantiated as necessary to determine if a qualified name
|
|
// is a type-name. Disambiguation precedes parsing, and a statement
|
|
// disambiguated as a declaration may be an ill-formed declaration.
|
|
|
|
// We don't have to parse all of the decl-specifier-seq part. There's only
|
|
// an ambiguity if the first decl-specifier is
|
|
// simple-type-specifier/typename-specifier followed by a '(', which may
|
|
// indicate a function-style cast expression.
|
|
// isCXXDeclarationSpecifier will return TPResult::Ambiguous only in such
|
|
// a case.
|
|
|
|
bool InvalidAsDeclaration = false;
|
|
TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
|
|
&InvalidAsDeclaration);
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR != TPResult::False; // Returns true for TPResult::True or
|
|
// TPResult::Error.
|
|
|
|
// FIXME: TryParseSimpleDeclaration doesn't look past the first initializer,
|
|
// and so gets some cases wrong. We can't carry on if we've already seen
|
|
// something which makes this statement invalid as a declaration in this case,
|
|
// since it can cause us to misparse valid code. Revisit this once
|
|
// TryParseInitDeclaratorList is fixed.
|
|
if (InvalidAsDeclaration)
|
|
return false;
|
|
|
|
// FIXME: Add statistics about the number of ambiguous statements encountered
|
|
// and how they were resolved (number of declarations+number of expressions).
|
|
|
|
// Ok, we have a simple-type-specifier/typename-specifier followed by a '(',
|
|
// or an identifier which doesn't resolve as anything. We need tentative
|
|
// parsing...
|
|
|
|
{
|
|
RevertingTentativeParsingAction PA(*this);
|
|
TPR = TryParseSimpleDeclaration(AllowForRangeDecl);
|
|
}
|
|
|
|
// In case of an error, let the declaration parsing code handle it.
|
|
if (TPR == TPResult::Error)
|
|
return true;
|
|
|
|
// Declarations take precedence over expressions.
|
|
if (TPR == TPResult::Ambiguous)
|
|
TPR = TPResult::True;
|
|
|
|
assert(TPR == TPResult::True || TPR == TPResult::False);
|
|
return TPR == TPResult::True;
|
|
}
|
|
|
|
/// Try to consume a token sequence that we've already identified as
|
|
/// (potentially) starting a decl-specifier.
|
|
Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
|
|
switch (Tok.getKind()) {
|
|
case tok::kw__Atomic:
|
|
if (NextToken().isNot(tok::l_paren)) {
|
|
ConsumeToken();
|
|
break;
|
|
}
|
|
// Fall through.
|
|
case tok::kw_typeof:
|
|
case tok::kw___attribute:
|
|
case tok::kw___underlying_type: {
|
|
ConsumeToken();
|
|
if (Tok.isNot(tok::l_paren))
|
|
return TPResult::Error;
|
|
ConsumeParen();
|
|
if (!SkipUntil(tok::r_paren))
|
|
return TPResult::Error;
|
|
break;
|
|
}
|
|
|
|
case tok::kw_class:
|
|
case tok::kw_struct:
|
|
case tok::kw_union:
|
|
case tok::kw___interface:
|
|
case tok::kw_enum:
|
|
// elaborated-type-specifier:
|
|
// class-key attribute-specifier-seq[opt]
|
|
// nested-name-specifier[opt] identifier
|
|
// class-key nested-name-specifier[opt] template[opt] simple-template-id
|
|
// enum nested-name-specifier[opt] identifier
|
|
//
|
|
// FIXME: We don't support class-specifiers nor enum-specifiers here.
|
|
ConsumeToken();
|
|
|
|
// Skip attributes.
|
|
while (Tok.isOneOf(tok::l_square, tok::kw___attribute, tok::kw___declspec,
|
|
tok::kw_alignas)) {
|
|
if (Tok.is(tok::l_square)) {
|
|
ConsumeBracket();
|
|
if (!SkipUntil(tok::r_square))
|
|
return TPResult::Error;
|
|
} else {
|
|
ConsumeToken();
|
|
if (Tok.isNot(tok::l_paren))
|
|
return TPResult::Error;
|
|
ConsumeParen();
|
|
if (!SkipUntil(tok::r_paren))
|
|
return TPResult::Error;
|
|
}
|
|
}
|
|
|
|
if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype,
|
|
tok::annot_template_id) &&
|
|
TryAnnotateCXXScopeToken())
|
|
return TPResult::Error;
|
|
if (Tok.is(tok::annot_cxxscope))
|
|
ConsumeAnnotationToken();
|
|
if (Tok.is(tok::identifier))
|
|
ConsumeToken();
|
|
else if (Tok.is(tok::annot_template_id))
|
|
ConsumeAnnotationToken();
|
|
else
|
|
return TPResult::Error;
|
|
break;
|
|
|
|
case tok::annot_cxxscope:
|
|
ConsumeAnnotationToken();
|
|
// Fall through.
|
|
default:
|
|
ConsumeAnyToken();
|
|
|
|
if (getLangOpts().ObjC1 && Tok.is(tok::less))
|
|
return TryParseProtocolQualifiers();
|
|
break;
|
|
}
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
/// simple-declaration:
|
|
/// decl-specifier-seq init-declarator-list[opt] ';'
|
|
///
|
|
/// (if AllowForRangeDecl specified)
|
|
/// for ( for-range-declaration : for-range-initializer ) statement
|
|
/// for-range-declaration:
|
|
/// attribute-specifier-seqopt type-specifier-seq declarator
|
|
///
|
|
Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
|
|
if (TryConsumeDeclarationSpecifier() == TPResult::Error)
|
|
return TPResult::Error;
|
|
|
|
// Two decl-specifiers in a row conclusively disambiguate this as being a
|
|
// simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
|
|
// overwhelmingly common case that the next token is a '('.
|
|
if (Tok.isNot(tok::l_paren)) {
|
|
TPResult TPR = isCXXDeclarationSpecifier();
|
|
if (TPR == TPResult::Ambiguous)
|
|
return TPResult::True;
|
|
if (TPR == TPResult::True || TPR == TPResult::Error)
|
|
return TPR;
|
|
assert(TPR == TPResult::False);
|
|
}
|
|
|
|
TPResult TPR = TryParseInitDeclaratorList();
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR;
|
|
|
|
if (Tok.isNot(tok::semi) && (!AllowForRangeDecl || Tok.isNot(tok::colon)))
|
|
return TPResult::False;
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
/// Tentatively parse an init-declarator-list in order to disambiguate it from
|
|
/// an expression.
|
|
///
|
|
/// init-declarator-list:
|
|
/// init-declarator
|
|
/// init-declarator-list ',' init-declarator
|
|
///
|
|
/// init-declarator:
|
|
/// declarator initializer[opt]
|
|
/// [GNU] declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
|
|
///
|
|
/// initializer:
|
|
/// brace-or-equal-initializer
|
|
/// '(' expression-list ')'
|
|
///
|
|
/// brace-or-equal-initializer:
|
|
/// '=' initializer-clause
|
|
/// [C++11] braced-init-list
|
|
///
|
|
/// initializer-clause:
|
|
/// assignment-expression
|
|
/// braced-init-list
|
|
///
|
|
/// braced-init-list:
|
|
/// '{' initializer-list ','[opt] '}'
|
|
/// '{' '}'
|
|
///
|
|
Parser::TPResult Parser::TryParseInitDeclaratorList() {
|
|
while (1) {
|
|
// declarator
|
|
TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR;
|
|
|
|
// [GNU] simple-asm-expr[opt] attributes[opt]
|
|
if (Tok.isOneOf(tok::kw_asm, tok::kw___attribute))
|
|
return TPResult::True;
|
|
|
|
// initializer[opt]
|
|
if (Tok.is(tok::l_paren)) {
|
|
// Parse through the parens.
|
|
ConsumeParen();
|
|
if (!SkipUntil(tok::r_paren, StopAtSemi))
|
|
return TPResult::Error;
|
|
} else if (Tok.is(tok::l_brace)) {
|
|
// A left-brace here is sufficient to disambiguate the parse; an
|
|
// expression can never be followed directly by a braced-init-list.
|
|
return TPResult::True;
|
|
} else if (Tok.is(tok::equal) || isTokIdentifier_in()) {
|
|
// MSVC and g++ won't examine the rest of declarators if '=' is
|
|
// encountered; they just conclude that we have a declaration.
|
|
// EDG parses the initializer completely, which is the proper behavior
|
|
// for this case.
|
|
//
|
|
// At present, Clang follows MSVC and g++, since the parser does not have
|
|
// the ability to parse an expression fully without recording the
|
|
// results of that parse.
|
|
// FIXME: Handle this case correctly.
|
|
//
|
|
// Also allow 'in' after an Objective-C declaration as in:
|
|
// for (int (^b)(void) in array). Ideally this should be done in the
|
|
// context of parsing for-init-statement of a foreach statement only. But,
|
|
// in any other context 'in' is invalid after a declaration and parser
|
|
// issues the error regardless of outcome of this decision.
|
|
// FIXME: Change if above assumption does not hold.
|
|
return TPResult::True;
|
|
}
|
|
|
|
if (!TryConsumeToken(tok::comma))
|
|
break;
|
|
}
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
struct Parser::ConditionDeclarationOrInitStatementState {
|
|
Parser &P;
|
|
bool CanBeExpression = true;
|
|
bool CanBeCondition = true;
|
|
bool CanBeInitStatement;
|
|
|
|
ConditionDeclarationOrInitStatementState(Parser &P, bool CanBeInitStatement)
|
|
: P(P), CanBeInitStatement(CanBeInitStatement) {}
|
|
|
|
void markNotExpression() {
|
|
CanBeExpression = false;
|
|
|
|
if (CanBeCondition && CanBeInitStatement) {
|
|
// FIXME: Unify the parsing codepaths for condition variables and
|
|
// simple-declarations so that we don't need to eagerly figure out which
|
|
// kind we have here. (Just parse init-declarators until we reach a
|
|
// semicolon or right paren.)
|
|
RevertingTentativeParsingAction PA(P);
|
|
P.SkipUntil(tok::r_paren, tok::semi, StopBeforeMatch);
|
|
if (P.Tok.isNot(tok::r_paren))
|
|
CanBeCondition = false;
|
|
if (P.Tok.isNot(tok::semi))
|
|
CanBeInitStatement = false;
|
|
}
|
|
}
|
|
|
|
bool markNotCondition() {
|
|
CanBeCondition = false;
|
|
return !CanBeInitStatement || !CanBeExpression;
|
|
}
|
|
|
|
bool update(TPResult IsDecl) {
|
|
switch (IsDecl) {
|
|
case TPResult::True:
|
|
markNotExpression();
|
|
return true;
|
|
case TPResult::False:
|
|
CanBeCondition = CanBeInitStatement = false;
|
|
return true;
|
|
case TPResult::Ambiguous:
|
|
return false;
|
|
case TPResult::Error:
|
|
CanBeExpression = CanBeCondition = CanBeInitStatement = false;
|
|
return true;
|
|
}
|
|
llvm_unreachable("unknown tentative parse result");
|
|
}
|
|
|
|
ConditionOrInitStatement result() const {
|
|
assert(CanBeExpression + CanBeCondition + CanBeInitStatement < 2 &&
|
|
"result called but not yet resolved");
|
|
if (CanBeExpression)
|
|
return ConditionOrInitStatement::Expression;
|
|
if (CanBeCondition)
|
|
return ConditionOrInitStatement::ConditionDecl;
|
|
if (CanBeInitStatement)
|
|
return ConditionOrInitStatement::InitStmtDecl;
|
|
return ConditionOrInitStatement::Error;
|
|
}
|
|
};
|
|
|
|
/// \brief Disambiguates between a declaration in a condition, a
|
|
/// simple-declaration in an init-statement, and an expression for
|
|
/// a condition of a if/switch statement.
|
|
///
|
|
/// condition:
|
|
/// expression
|
|
/// type-specifier-seq declarator '=' assignment-expression
|
|
/// [C++11] type-specifier-seq declarator '=' initializer-clause
|
|
/// [C++11] type-specifier-seq declarator braced-init-list
|
|
/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
|
|
/// '=' assignment-expression
|
|
/// simple-declaration:
|
|
/// decl-specifier-seq init-declarator-list[opt] ';'
|
|
///
|
|
/// Note that, unlike isCXXSimpleDeclaration, we must disambiguate all the way
|
|
/// to the ';' to disambiguate cases like 'int(x))' (an expression) from
|
|
/// 'int(x);' (a simple-declaration in an init-statement).
|
|
Parser::ConditionOrInitStatement
|
|
Parser::isCXXConditionDeclarationOrInitStatement(bool CanBeInitStatement) {
|
|
ConditionDeclarationOrInitStatementState State(*this, CanBeInitStatement);
|
|
|
|
if (State.update(isCXXDeclarationSpecifier()))
|
|
return State.result();
|
|
|
|
// It might be a declaration; we need tentative parsing.
|
|
RevertingTentativeParsingAction PA(*this);
|
|
|
|
// FIXME: A tag definition unambiguously tells us this is an init-statement.
|
|
if (State.update(TryConsumeDeclarationSpecifier()))
|
|
return State.result();
|
|
assert(Tok.is(tok::l_paren) && "Expected '('");
|
|
|
|
while (true) {
|
|
// Consume a declarator.
|
|
if (State.update(TryParseDeclarator(false/*mayBeAbstract*/)))
|
|
return State.result();
|
|
|
|
// Attributes, asm label, or an initializer imply this is not an expression.
|
|
// FIXME: Disambiguate properly after an = instead of assuming that it's a
|
|
// valid declaration.
|
|
if (Tok.isOneOf(tok::equal, tok::kw_asm, tok::kw___attribute) ||
|
|
(getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) {
|
|
State.markNotExpression();
|
|
return State.result();
|
|
}
|
|
|
|
// At this point, it can't be a condition any more, because a condition
|
|
// must have a brace-or-equal-initializer.
|
|
if (State.markNotCondition())
|
|
return State.result();
|
|
|
|
// A parenthesized initializer could be part of an expression or a
|
|
// simple-declaration.
|
|
if (Tok.is(tok::l_paren)) {
|
|
ConsumeParen();
|
|
SkipUntil(tok::r_paren, StopAtSemi);
|
|
}
|
|
|
|
if (!TryConsumeToken(tok::comma))
|
|
break;
|
|
}
|
|
|
|
// We reached the end. If it can now be some kind of decl, then it is.
|
|
if (State.CanBeCondition && Tok.is(tok::r_paren))
|
|
return ConditionOrInitStatement::ConditionDecl;
|
|
else if (State.CanBeInitStatement && Tok.is(tok::semi))
|
|
return ConditionOrInitStatement::InitStmtDecl;
|
|
else
|
|
return ConditionOrInitStatement::Expression;
|
|
}
|
|
|
|
/// \brief Determine whether the next set of tokens contains a type-id.
|
|
///
|
|
/// The context parameter states what context we're parsing right
|
|
/// now, which affects how this routine copes with the token
|
|
/// following the type-id. If the context is TypeIdInParens, we have
|
|
/// already parsed the '(' and we will cease lookahead when we hit
|
|
/// the corresponding ')'. If the context is
|
|
/// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
|
|
/// before this template argument, and will cease lookahead when we
|
|
/// hit a '>', '>>' (in C++0x), or ','; or, in C++0x, an ellipsis immediately
|
|
/// preceding such. Returns true for a type-id and false for an expression.
|
|
/// If during the disambiguation process a parsing error is encountered,
|
|
/// the function returns true to let the declaration parsing code handle it.
|
|
///
|
|
/// type-id:
|
|
/// type-specifier-seq abstract-declarator[opt]
|
|
///
|
|
bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
|
|
|
|
isAmbiguous = false;
|
|
|
|
// C++ 8.2p2:
|
|
// The ambiguity arising from the similarity between a function-style cast and
|
|
// a type-id can occur in different contexts. The ambiguity appears as a
|
|
// choice between a function-style cast expression and a declaration of a
|
|
// type. The resolution is that any construct that could possibly be a type-id
|
|
// in its syntactic context shall be considered a type-id.
|
|
|
|
TPResult TPR = isCXXDeclarationSpecifier();
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR != TPResult::False; // Returns true for TPResult::True or
|
|
// TPResult::Error.
|
|
|
|
// FIXME: Add statistics about the number of ambiguous statements encountered
|
|
// and how they were resolved (number of declarations+number of expressions).
|
|
|
|
// Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
|
|
// We need tentative parsing...
|
|
|
|
RevertingTentativeParsingAction PA(*this);
|
|
|
|
// type-specifier-seq
|
|
TryConsumeDeclarationSpecifier();
|
|
assert(Tok.is(tok::l_paren) && "Expected '('");
|
|
|
|
// declarator
|
|
TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
|
|
|
|
// In case of an error, let the declaration parsing code handle it.
|
|
if (TPR == TPResult::Error)
|
|
TPR = TPResult::True;
|
|
|
|
if (TPR == TPResult::Ambiguous) {
|
|
// We are supposed to be inside parens, so if after the abstract declarator
|
|
// we encounter a ')' this is a type-id, otherwise it's an expression.
|
|
if (Context == TypeIdInParens && Tok.is(tok::r_paren)) {
|
|
TPR = TPResult::True;
|
|
isAmbiguous = true;
|
|
|
|
// We are supposed to be inside a template argument, so if after
|
|
// the abstract declarator we encounter a '>', '>>' (in C++0x), or
|
|
// ','; or, in C++0x, an ellipsis immediately preceding such, this
|
|
// is a type-id. Otherwise, it's an expression.
|
|
} else if (Context == TypeIdAsTemplateArgument &&
|
|
(Tok.isOneOf(tok::greater, tok::comma) ||
|
|
(getLangOpts().CPlusPlus11 &&
|
|
(Tok.is(tok::greatergreater) ||
|
|
(Tok.is(tok::ellipsis) &&
|
|
NextToken().isOneOf(tok::greater, tok::greatergreater,
|
|
tok::comma)))))) {
|
|
TPR = TPResult::True;
|
|
isAmbiguous = true;
|
|
|
|
} else
|
|
TPR = TPResult::False;
|
|
}
|
|
|
|
assert(TPR == TPResult::True || TPR == TPResult::False);
|
|
return TPR == TPResult::True;
|
|
}
|
|
|
|
/// \brief Returns true if this is a C++11 attribute-specifier. Per
|
|
/// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
|
|
/// always introduce an attribute. In Objective-C++11, this rule does not
|
|
/// apply if either '[' begins a message-send.
|
|
///
|
|
/// If Disambiguate is true, we try harder to determine whether a '[[' starts
|
|
/// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
|
|
///
|
|
/// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
|
|
/// Obj-C message send or the start of an attribute. Otherwise, we assume it
|
|
/// is not an Obj-C message send.
|
|
///
|
|
/// C++11 [dcl.attr.grammar]:
|
|
///
|
|
/// attribute-specifier:
|
|
/// '[' '[' attribute-list ']' ']'
|
|
/// alignment-specifier
|
|
///
|
|
/// attribute-list:
|
|
/// attribute[opt]
|
|
/// attribute-list ',' attribute[opt]
|
|
/// attribute '...'
|
|
/// attribute-list ',' attribute '...'
|
|
///
|
|
/// attribute:
|
|
/// attribute-token attribute-argument-clause[opt]
|
|
///
|
|
/// attribute-token:
|
|
/// identifier
|
|
/// identifier '::' identifier
|
|
///
|
|
/// attribute-argument-clause:
|
|
/// '(' balanced-token-seq ')'
|
|
Parser::CXX11AttributeKind
|
|
Parser::isCXX11AttributeSpecifier(bool Disambiguate,
|
|
bool OuterMightBeMessageSend) {
|
|
if (Tok.is(tok::kw_alignas))
|
|
return CAK_AttributeSpecifier;
|
|
|
|
if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
|
|
return CAK_NotAttributeSpecifier;
|
|
|
|
// No tentative parsing if we don't need to look for ']]' or a lambda.
|
|
if (!Disambiguate && !getLangOpts().ObjC1)
|
|
return CAK_AttributeSpecifier;
|
|
|
|
RevertingTentativeParsingAction PA(*this);
|
|
|
|
// Opening brackets were checked for above.
|
|
ConsumeBracket();
|
|
|
|
// Outside Obj-C++11, treat anything with a matching ']]' as an attribute.
|
|
if (!getLangOpts().ObjC1) {
|
|
ConsumeBracket();
|
|
|
|
bool IsAttribute = SkipUntil(tok::r_square);
|
|
IsAttribute &= Tok.is(tok::r_square);
|
|
|
|
return IsAttribute ? CAK_AttributeSpecifier : CAK_InvalidAttributeSpecifier;
|
|
}
|
|
|
|
// In Obj-C++11, we need to distinguish four situations:
|
|
// 1a) int x[[attr]]; C++11 attribute.
|
|
// 1b) [[attr]]; C++11 statement attribute.
|
|
// 2) int x[[obj](){ return 1; }()]; Lambda in array size/index.
|
|
// 3a) int x[[obj get]]; Message send in array size/index.
|
|
// 3b) [[Class alloc] init]; Message send in message send.
|
|
// 4) [[obj]{ return self; }() doStuff]; Lambda in message send.
|
|
// (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
|
|
|
|
// If we have a lambda-introducer, then this is definitely not a message send.
|
|
// FIXME: If this disambiguation is too slow, fold the tentative lambda parse
|
|
// into the tentative attribute parse below.
|
|
LambdaIntroducer Intro;
|
|
if (!TryParseLambdaIntroducer(Intro)) {
|
|
// A lambda cannot end with ']]', and an attribute must.
|
|
bool IsAttribute = Tok.is(tok::r_square);
|
|
|
|
if (IsAttribute)
|
|
// Case 1: C++11 attribute.
|
|
return CAK_AttributeSpecifier;
|
|
|
|
if (OuterMightBeMessageSend)
|
|
// Case 4: Lambda in message send.
|
|
return CAK_NotAttributeSpecifier;
|
|
|
|
// Case 2: Lambda in array size / index.
|
|
return CAK_InvalidAttributeSpecifier;
|
|
}
|
|
|
|
ConsumeBracket();
|
|
|
|
// If we don't have a lambda-introducer, then we have an attribute or a
|
|
// message-send.
|
|
bool IsAttribute = true;
|
|
while (Tok.isNot(tok::r_square)) {
|
|
if (Tok.is(tok::comma)) {
|
|
// Case 1: Stray commas can only occur in attributes.
|
|
return CAK_AttributeSpecifier;
|
|
}
|
|
|
|
// Parse the attribute-token, if present.
|
|
// C++11 [dcl.attr.grammar]:
|
|
// If a keyword or an alternative token that satisfies the syntactic
|
|
// requirements of an identifier is contained in an attribute-token,
|
|
// it is considered an identifier.
|
|
SourceLocation Loc;
|
|
if (!TryParseCXX11AttributeIdentifier(Loc)) {
|
|
IsAttribute = false;
|
|
break;
|
|
}
|
|
if (Tok.is(tok::coloncolon)) {
|
|
ConsumeToken();
|
|
if (!TryParseCXX11AttributeIdentifier(Loc)) {
|
|
IsAttribute = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Parse the attribute-argument-clause, if present.
|
|
if (Tok.is(tok::l_paren)) {
|
|
ConsumeParen();
|
|
if (!SkipUntil(tok::r_paren)) {
|
|
IsAttribute = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
TryConsumeToken(tok::ellipsis);
|
|
|
|
if (!TryConsumeToken(tok::comma))
|
|
break;
|
|
}
|
|
|
|
// An attribute must end ']]'.
|
|
if (IsAttribute) {
|
|
if (Tok.is(tok::r_square)) {
|
|
ConsumeBracket();
|
|
IsAttribute = Tok.is(tok::r_square);
|
|
} else {
|
|
IsAttribute = false;
|
|
}
|
|
}
|
|
|
|
if (IsAttribute)
|
|
// Case 1: C++11 statement attribute.
|
|
return CAK_AttributeSpecifier;
|
|
|
|
// Case 3: Message send.
|
|
return CAK_NotAttributeSpecifier;
|
|
}
|
|
|
|
Parser::TPResult Parser::TryParsePtrOperatorSeq() {
|
|
while (true) {
|
|
if (Tok.isOneOf(tok::coloncolon, tok::identifier))
|
|
if (TryAnnotateCXXScopeToken(true))
|
|
return TPResult::Error;
|
|
|
|
if (Tok.isOneOf(tok::star, tok::amp, tok::caret, tok::ampamp) ||
|
|
(Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
|
|
// ptr-operator
|
|
ConsumeAnyToken();
|
|
while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict,
|
|
tok::kw__Nonnull, tok::kw__Nullable,
|
|
tok::kw__Null_unspecified))
|
|
ConsumeToken();
|
|
} else {
|
|
return TPResult::True;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// operator-function-id:
|
|
/// 'operator' operator
|
|
///
|
|
/// operator: one of
|
|
/// new delete new[] delete[] + - * / % ^ [...]
|
|
///
|
|
/// conversion-function-id:
|
|
/// 'operator' conversion-type-id
|
|
///
|
|
/// conversion-type-id:
|
|
/// type-specifier-seq conversion-declarator[opt]
|
|
///
|
|
/// conversion-declarator:
|
|
/// ptr-operator conversion-declarator[opt]
|
|
///
|
|
/// literal-operator-id:
|
|
/// 'operator' string-literal identifier
|
|
/// 'operator' user-defined-string-literal
|
|
Parser::TPResult Parser::TryParseOperatorId() {
|
|
assert(Tok.is(tok::kw_operator));
|
|
ConsumeToken();
|
|
|
|
// Maybe this is an operator-function-id.
|
|
switch (Tok.getKind()) {
|
|
case tok::kw_new: case tok::kw_delete:
|
|
ConsumeToken();
|
|
if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
|
|
ConsumeBracket();
|
|
ConsumeBracket();
|
|
}
|
|
return TPResult::True;
|
|
|
|
#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemOnly) \
|
|
case tok::Token:
|
|
#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemOnly)
|
|
#include "clang/Basic/OperatorKinds.def"
|
|
ConsumeToken();
|
|
return TPResult::True;
|
|
|
|
case tok::l_square:
|
|
if (NextToken().is(tok::r_square)) {
|
|
ConsumeBracket();
|
|
ConsumeBracket();
|
|
return TPResult::True;
|
|
}
|
|
break;
|
|
|
|
case tok::l_paren:
|
|
if (NextToken().is(tok::r_paren)) {
|
|
ConsumeParen();
|
|
ConsumeParen();
|
|
return TPResult::True;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Maybe this is a literal-operator-id.
|
|
if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
|
|
bool FoundUDSuffix = false;
|
|
do {
|
|
FoundUDSuffix |= Tok.hasUDSuffix();
|
|
ConsumeStringToken();
|
|
} while (isTokenStringLiteral());
|
|
|
|
if (!FoundUDSuffix) {
|
|
if (Tok.is(tok::identifier))
|
|
ConsumeToken();
|
|
else
|
|
return TPResult::Error;
|
|
}
|
|
return TPResult::True;
|
|
}
|
|
|
|
// Maybe this is a conversion-function-id.
|
|
bool AnyDeclSpecifiers = false;
|
|
while (true) {
|
|
TPResult TPR = isCXXDeclarationSpecifier();
|
|
if (TPR == TPResult::Error)
|
|
return TPR;
|
|
if (TPR == TPResult::False) {
|
|
if (!AnyDeclSpecifiers)
|
|
return TPResult::Error;
|
|
break;
|
|
}
|
|
if (TryConsumeDeclarationSpecifier() == TPResult::Error)
|
|
return TPResult::Error;
|
|
AnyDeclSpecifiers = true;
|
|
}
|
|
return TryParsePtrOperatorSeq();
|
|
}
|
|
|
|
/// declarator:
|
|
/// direct-declarator
|
|
/// ptr-operator declarator
|
|
///
|
|
/// direct-declarator:
|
|
/// declarator-id
|
|
/// direct-declarator '(' parameter-declaration-clause ')'
|
|
/// cv-qualifier-seq[opt] exception-specification[opt]
|
|
/// direct-declarator '[' constant-expression[opt] ']'
|
|
/// '(' declarator ')'
|
|
/// [GNU] '(' attributes declarator ')'
|
|
///
|
|
/// abstract-declarator:
|
|
/// ptr-operator abstract-declarator[opt]
|
|
/// direct-abstract-declarator
|
|
///
|
|
/// direct-abstract-declarator:
|
|
/// direct-abstract-declarator[opt]
|
|
/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
|
|
/// exception-specification[opt]
|
|
/// direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
|
|
/// '(' abstract-declarator ')'
|
|
/// [C++0x] ...
|
|
///
|
|
/// ptr-operator:
|
|
/// '*' cv-qualifier-seq[opt]
|
|
/// '&'
|
|
/// [C++0x] '&&' [TODO]
|
|
/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
|
|
///
|
|
/// cv-qualifier-seq:
|
|
/// cv-qualifier cv-qualifier-seq[opt]
|
|
///
|
|
/// cv-qualifier:
|
|
/// 'const'
|
|
/// 'volatile'
|
|
///
|
|
/// declarator-id:
|
|
/// '...'[opt] id-expression
|
|
///
|
|
/// id-expression:
|
|
/// unqualified-id
|
|
/// qualified-id [TODO]
|
|
///
|
|
/// unqualified-id:
|
|
/// identifier
|
|
/// operator-function-id
|
|
/// conversion-function-id
|
|
/// literal-operator-id
|
|
/// '~' class-name [TODO]
|
|
/// '~' decltype-specifier [TODO]
|
|
/// template-id [TODO]
|
|
///
|
|
Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
|
|
bool mayHaveIdentifier,
|
|
bool mayHaveDirectInit) {
|
|
// declarator:
|
|
// direct-declarator
|
|
// ptr-operator declarator
|
|
if (TryParsePtrOperatorSeq() == TPResult::Error)
|
|
return TPResult::Error;
|
|
|
|
// direct-declarator:
|
|
// direct-abstract-declarator:
|
|
if (Tok.is(tok::ellipsis))
|
|
ConsumeToken();
|
|
|
|
if ((Tok.isOneOf(tok::identifier, tok::kw_operator) ||
|
|
(Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) ||
|
|
NextToken().is(tok::kw_operator)))) &&
|
|
mayHaveIdentifier) {
|
|
// declarator-id
|
|
if (Tok.is(tok::annot_cxxscope))
|
|
ConsumeAnnotationToken();
|
|
else if (Tok.is(tok::identifier))
|
|
TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
|
|
if (Tok.is(tok::kw_operator)) {
|
|
if (TryParseOperatorId() == TPResult::Error)
|
|
return TPResult::Error;
|
|
} else
|
|
ConsumeToken();
|
|
} else if (Tok.is(tok::l_paren)) {
|
|
ConsumeParen();
|
|
if (mayBeAbstract &&
|
|
(Tok.is(tok::r_paren) || // 'int()' is a function.
|
|
// 'int(...)' is a function.
|
|
(Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
|
|
isDeclarationSpecifier())) { // 'int(int)' is a function.
|
|
// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
|
|
// exception-specification[opt]
|
|
TPResult TPR = TryParseFunctionDeclarator();
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR;
|
|
} else {
|
|
// '(' declarator ')'
|
|
// '(' attributes declarator ')'
|
|
// '(' abstract-declarator ')'
|
|
if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec, tok::kw___cdecl,
|
|
tok::kw___stdcall, tok::kw___fastcall, tok::kw___thiscall,
|
|
tok::kw___regcall, tok::kw___vectorcall))
|
|
return TPResult::True; // attributes indicate declaration
|
|
TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR;
|
|
if (Tok.isNot(tok::r_paren))
|
|
return TPResult::False;
|
|
ConsumeParen();
|
|
}
|
|
} else if (!mayBeAbstract) {
|
|
return TPResult::False;
|
|
}
|
|
|
|
if (mayHaveDirectInit)
|
|
return TPResult::Ambiguous;
|
|
|
|
while (1) {
|
|
TPResult TPR(TPResult::Ambiguous);
|
|
|
|
if (Tok.is(tok::l_paren)) {
|
|
// Check whether we have a function declarator or a possible ctor-style
|
|
// initializer that follows the declarator. Note that ctor-style
|
|
// initializers are not possible in contexts where abstract declarators
|
|
// are allowed.
|
|
if (!mayBeAbstract && !isCXXFunctionDeclarator())
|
|
break;
|
|
|
|
// direct-declarator '(' parameter-declaration-clause ')'
|
|
// cv-qualifier-seq[opt] exception-specification[opt]
|
|
ConsumeParen();
|
|
TPR = TryParseFunctionDeclarator();
|
|
} else if (Tok.is(tok::l_square)) {
|
|
// direct-declarator '[' constant-expression[opt] ']'
|
|
// direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
|
|
TPR = TryParseBracketDeclarator();
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR;
|
|
}
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
Parser::TPResult
|
|
Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
|
|
switch (Kind) {
|
|
// Obviously starts an expression.
|
|
case tok::numeric_constant:
|
|
case tok::char_constant:
|
|
case tok::wide_char_constant:
|
|
case tok::utf8_char_constant:
|
|
case tok::utf16_char_constant:
|
|
case tok::utf32_char_constant:
|
|
case tok::string_literal:
|
|
case tok::wide_string_literal:
|
|
case tok::utf8_string_literal:
|
|
case tok::utf16_string_literal:
|
|
case tok::utf32_string_literal:
|
|
case tok::l_square:
|
|
case tok::l_paren:
|
|
case tok::amp:
|
|
case tok::ampamp:
|
|
case tok::star:
|
|
case tok::plus:
|
|
case tok::plusplus:
|
|
case tok::minus:
|
|
case tok::minusminus:
|
|
case tok::tilde:
|
|
case tok::exclaim:
|
|
case tok::kw_sizeof:
|
|
case tok::kw___func__:
|
|
case tok::kw_const_cast:
|
|
case tok::kw_delete:
|
|
case tok::kw_dynamic_cast:
|
|
case tok::kw_false:
|
|
case tok::kw_new:
|
|
case tok::kw_operator:
|
|
case tok::kw_reinterpret_cast:
|
|
case tok::kw_static_cast:
|
|
case tok::kw_this:
|
|
case tok::kw_throw:
|
|
case tok::kw_true:
|
|
case tok::kw_typeid:
|
|
case tok::kw_alignof:
|
|
case tok::kw_noexcept:
|
|
case tok::kw_nullptr:
|
|
case tok::kw__Alignof:
|
|
case tok::kw___null:
|
|
case tok::kw___alignof:
|
|
case tok::kw___builtin_choose_expr:
|
|
case tok::kw___builtin_offsetof:
|
|
case tok::kw___builtin_va_arg:
|
|
case tok::kw___imag:
|
|
case tok::kw___real:
|
|
case tok::kw___FUNCTION__:
|
|
case tok::kw___FUNCDNAME__:
|
|
case tok::kw___FUNCSIG__:
|
|
case tok::kw_L__FUNCTION__:
|
|
case tok::kw___PRETTY_FUNCTION__:
|
|
case tok::kw___uuidof:
|
|
#define TYPE_TRAIT(N,Spelling,K) \
|
|
case tok::kw_##Spelling:
|
|
#include "clang/Basic/TokenKinds.def"
|
|
return TPResult::True;
|
|
|
|
// Obviously starts a type-specifier-seq:
|
|
case tok::kw_char:
|
|
case tok::kw_const:
|
|
case tok::kw_double:
|
|
case tok::kw__Float16:
|
|
case tok::kw___float128:
|
|
case tok::kw_enum:
|
|
case tok::kw_half:
|
|
case tok::kw_float:
|
|
case tok::kw_int:
|
|
case tok::kw_long:
|
|
case tok::kw___int64:
|
|
case tok::kw___int128:
|
|
case tok::kw_restrict:
|
|
case tok::kw_short:
|
|
case tok::kw_signed:
|
|
case tok::kw_struct:
|
|
case tok::kw_union:
|
|
case tok::kw_unsigned:
|
|
case tok::kw_void:
|
|
case tok::kw_volatile:
|
|
case tok::kw__Bool:
|
|
case tok::kw__Complex:
|
|
case tok::kw_class:
|
|
case tok::kw_typename:
|
|
case tok::kw_wchar_t:
|
|
case tok::kw_char16_t:
|
|
case tok::kw_char32_t:
|
|
case tok::kw__Decimal32:
|
|
case tok::kw__Decimal64:
|
|
case tok::kw__Decimal128:
|
|
case tok::kw___interface:
|
|
case tok::kw___thread:
|
|
case tok::kw_thread_local:
|
|
case tok::kw__Thread_local:
|
|
case tok::kw_typeof:
|
|
case tok::kw___underlying_type:
|
|
case tok::kw___cdecl:
|
|
case tok::kw___stdcall:
|
|
case tok::kw___fastcall:
|
|
case tok::kw___thiscall:
|
|
case tok::kw___regcall:
|
|
case tok::kw___vectorcall:
|
|
case tok::kw___unaligned:
|
|
case tok::kw___vector:
|
|
case tok::kw___pixel:
|
|
case tok::kw___bool:
|
|
case tok::kw__Atomic:
|
|
#define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
|
|
#include "clang/Basic/OpenCLImageTypes.def"
|
|
case tok::kw___unknown_anytype:
|
|
return TPResult::False;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
|
|
return std::find(TentativelyDeclaredIdentifiers.begin(),
|
|
TentativelyDeclaredIdentifiers.end(), II)
|
|
!= TentativelyDeclaredIdentifiers.end();
|
|
}
|
|
|
|
namespace {
|
|
class TentativeParseCCC : public CorrectionCandidateCallback {
|
|
public:
|
|
TentativeParseCCC(const Token &Next) {
|
|
WantRemainingKeywords = false;
|
|
WantTypeSpecifiers = Next.isOneOf(tok::l_paren, tok::r_paren, tok::greater,
|
|
tok::l_brace, tok::identifier);
|
|
}
|
|
|
|
bool ValidateCandidate(const TypoCorrection &Candidate) override {
|
|
// Reject any candidate that only resolves to instance members since they
|
|
// aren't viable as standalone identifiers instead of member references.
|
|
if (Candidate.isResolved() && !Candidate.isKeyword() &&
|
|
std::all_of(Candidate.begin(), Candidate.end(),
|
|
[](NamedDecl *ND) { return ND->isCXXInstanceMember(); }))
|
|
return false;
|
|
|
|
return CorrectionCandidateCallback::ValidateCandidate(Candidate);
|
|
}
|
|
};
|
|
}
|
|
/// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
|
|
/// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
|
|
/// be either a decl-specifier or a function-style cast, and TPResult::Error
|
|
/// if a parsing error was found and reported.
|
|
///
|
|
/// If HasMissingTypename is provided, a name with a dependent scope specifier
|
|
/// will be treated as ambiguous if the 'typename' keyword is missing. If this
|
|
/// happens, *HasMissingTypename will be set to 'true'. This will also be used
|
|
/// as an indicator that undeclared identifiers (which will trigger a later
|
|
/// parse error) should be treated as types. Returns TPResult::Ambiguous in
|
|
/// such cases.
|
|
///
|
|
/// decl-specifier:
|
|
/// storage-class-specifier
|
|
/// type-specifier
|
|
/// function-specifier
|
|
/// 'friend'
|
|
/// 'typedef'
|
|
/// [C++11] 'constexpr'
|
|
/// [GNU] attributes declaration-specifiers[opt]
|
|
///
|
|
/// storage-class-specifier:
|
|
/// 'register'
|
|
/// 'static'
|
|
/// 'extern'
|
|
/// 'mutable'
|
|
/// 'auto'
|
|
/// [GNU] '__thread'
|
|
/// [C++11] 'thread_local'
|
|
/// [C11] '_Thread_local'
|
|
///
|
|
/// function-specifier:
|
|
/// 'inline'
|
|
/// 'virtual'
|
|
/// 'explicit'
|
|
///
|
|
/// typedef-name:
|
|
/// identifier
|
|
///
|
|
/// type-specifier:
|
|
/// simple-type-specifier
|
|
/// class-specifier
|
|
/// enum-specifier
|
|
/// elaborated-type-specifier
|
|
/// typename-specifier
|
|
/// cv-qualifier
|
|
///
|
|
/// simple-type-specifier:
|
|
/// '::'[opt] nested-name-specifier[opt] type-name
|
|
/// '::'[opt] nested-name-specifier 'template'
|
|
/// simple-template-id [TODO]
|
|
/// 'char'
|
|
/// 'wchar_t'
|
|
/// 'bool'
|
|
/// 'short'
|
|
/// 'int'
|
|
/// 'long'
|
|
/// 'signed'
|
|
/// 'unsigned'
|
|
/// 'float'
|
|
/// 'double'
|
|
/// 'void'
|
|
/// [GNU] typeof-specifier
|
|
/// [GNU] '_Complex'
|
|
/// [C++11] 'auto'
|
|
/// [GNU] '__auto_type'
|
|
/// [C++11] 'decltype' ( expression )
|
|
/// [C++1y] 'decltype' ( 'auto' )
|
|
///
|
|
/// type-name:
|
|
/// class-name
|
|
/// enum-name
|
|
/// typedef-name
|
|
///
|
|
/// elaborated-type-specifier:
|
|
/// class-key '::'[opt] nested-name-specifier[opt] identifier
|
|
/// class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
|
|
/// simple-template-id
|
|
/// 'enum' '::'[opt] nested-name-specifier[opt] identifier
|
|
///
|
|
/// enum-name:
|
|
/// identifier
|
|
///
|
|
/// enum-specifier:
|
|
/// 'enum' identifier[opt] '{' enumerator-list[opt] '}'
|
|
/// 'enum' identifier[opt] '{' enumerator-list ',' '}'
|
|
///
|
|
/// class-specifier:
|
|
/// class-head '{' member-specification[opt] '}'
|
|
///
|
|
/// class-head:
|
|
/// class-key identifier[opt] base-clause[opt]
|
|
/// class-key nested-name-specifier identifier base-clause[opt]
|
|
/// class-key nested-name-specifier[opt] simple-template-id
|
|
/// base-clause[opt]
|
|
///
|
|
/// class-key:
|
|
/// 'class'
|
|
/// 'struct'
|
|
/// 'union'
|
|
///
|
|
/// cv-qualifier:
|
|
/// 'const'
|
|
/// 'volatile'
|
|
/// [GNU] restrict
|
|
///
|
|
Parser::TPResult
|
|
Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
|
|
bool *HasMissingTypename) {
|
|
switch (Tok.getKind()) {
|
|
case tok::identifier: {
|
|
// Check for need to substitute AltiVec __vector keyword
|
|
// for "vector" identifier.
|
|
if (TryAltiVecVectorToken())
|
|
return TPResult::True;
|
|
|
|
const Token &Next = NextToken();
|
|
// In 'foo bar', 'foo' is always a type name outside of Objective-C.
|
|
if (!getLangOpts().ObjC1 && Next.is(tok::identifier))
|
|
return TPResult::True;
|
|
|
|
if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
|
|
// Determine whether this is a valid expression. If not, we will hit
|
|
// a parse error one way or another. In that case, tell the caller that
|
|
// this is ambiguous. Typo-correct to type and expression keywords and
|
|
// to types and identifiers, in order to try to recover from errors.
|
|
switch (TryAnnotateName(false /* no nested name specifier */,
|
|
llvm::make_unique<TentativeParseCCC>(Next))) {
|
|
case ANK_Error:
|
|
return TPResult::Error;
|
|
case ANK_TentativeDecl:
|
|
return TPResult::False;
|
|
case ANK_TemplateName:
|
|
// In C++17, this could be a type template for class template argument
|
|
// deduction. Try to form a type annotation for it. If we're in a
|
|
// template template argument, we'll undo this when checking the
|
|
// validity of the argument.
|
|
if (getLangOpts().CPlusPlus17) {
|
|
if (TryAnnotateTypeOrScopeToken())
|
|
return TPResult::Error;
|
|
if (Tok.isNot(tok::identifier))
|
|
break;
|
|
}
|
|
|
|
// A bare type template-name which can't be a template template
|
|
// argument is an error, and was probably intended to be a type.
|
|
return GreaterThanIsOperator ? TPResult::True : TPResult::False;
|
|
case ANK_Unresolved:
|
|
return HasMissingTypename ? TPResult::Ambiguous : TPResult::False;
|
|
case ANK_Success:
|
|
break;
|
|
}
|
|
assert(Tok.isNot(tok::identifier) &&
|
|
"TryAnnotateName succeeded without producing an annotation");
|
|
} else {
|
|
// This might possibly be a type with a dependent scope specifier and
|
|
// a missing 'typename' keyword. Don't use TryAnnotateName in this case,
|
|
// since it will annotate as a primary expression, and we want to use the
|
|
// "missing 'typename'" logic.
|
|
if (TryAnnotateTypeOrScopeToken())
|
|
return TPResult::Error;
|
|
// If annotation failed, assume it's a non-type.
|
|
// FIXME: If this happens due to an undeclared identifier, treat it as
|
|
// ambiguous.
|
|
if (Tok.is(tok::identifier))
|
|
return TPResult::False;
|
|
}
|
|
|
|
// We annotated this token as something. Recurse to handle whatever we got.
|
|
return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
|
|
}
|
|
|
|
case tok::kw_typename: // typename T::type
|
|
// Annotate typenames and C++ scope specifiers. If we get one, just
|
|
// recurse to handle whatever we get.
|
|
if (TryAnnotateTypeOrScopeToken())
|
|
return TPResult::Error;
|
|
return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
|
|
|
|
case tok::coloncolon: { // ::foo::bar
|
|
const Token &Next = NextToken();
|
|
if (Next.isOneOf(tok::kw_new, // ::new
|
|
tok::kw_delete)) // ::delete
|
|
return TPResult::False;
|
|
}
|
|
// Fall through.
|
|
case tok::kw___super:
|
|
case tok::kw_decltype:
|
|
// Annotate typenames and C++ scope specifiers. If we get one, just
|
|
// recurse to handle whatever we get.
|
|
if (TryAnnotateTypeOrScopeToken())
|
|
return TPResult::Error;
|
|
return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
|
|
|
|
// decl-specifier:
|
|
// storage-class-specifier
|
|
// type-specifier
|
|
// function-specifier
|
|
// 'friend'
|
|
// 'typedef'
|
|
// 'constexpr'
|
|
case tok::kw_friend:
|
|
case tok::kw_typedef:
|
|
case tok::kw_constexpr:
|
|
// storage-class-specifier
|
|
case tok::kw_register:
|
|
case tok::kw_static:
|
|
case tok::kw_extern:
|
|
case tok::kw_mutable:
|
|
case tok::kw_auto:
|
|
case tok::kw___thread:
|
|
case tok::kw_thread_local:
|
|
case tok::kw__Thread_local:
|
|
// function-specifier
|
|
case tok::kw_inline:
|
|
case tok::kw_virtual:
|
|
case tok::kw_explicit:
|
|
|
|
// Modules
|
|
case tok::kw___module_private__:
|
|
|
|
// Debugger support
|
|
case tok::kw___unknown_anytype:
|
|
|
|
// type-specifier:
|
|
// simple-type-specifier
|
|
// class-specifier
|
|
// enum-specifier
|
|
// elaborated-type-specifier
|
|
// typename-specifier
|
|
// cv-qualifier
|
|
|
|
// class-specifier
|
|
// elaborated-type-specifier
|
|
case tok::kw_class:
|
|
case tok::kw_struct:
|
|
case tok::kw_union:
|
|
case tok::kw___interface:
|
|
// enum-specifier
|
|
case tok::kw_enum:
|
|
// cv-qualifier
|
|
case tok::kw_const:
|
|
case tok::kw_volatile:
|
|
|
|
// GNU
|
|
case tok::kw_restrict:
|
|
case tok::kw__Complex:
|
|
case tok::kw___attribute:
|
|
case tok::kw___auto_type:
|
|
return TPResult::True;
|
|
|
|
// Microsoft
|
|
case tok::kw___declspec:
|
|
case tok::kw___cdecl:
|
|
case tok::kw___stdcall:
|
|
case tok::kw___fastcall:
|
|
case tok::kw___thiscall:
|
|
case tok::kw___regcall:
|
|
case tok::kw___vectorcall:
|
|
case tok::kw___w64:
|
|
case tok::kw___sptr:
|
|
case tok::kw___uptr:
|
|
case tok::kw___ptr64:
|
|
case tok::kw___ptr32:
|
|
case tok::kw___forceinline:
|
|
case tok::kw___unaligned:
|
|
case tok::kw__Nonnull:
|
|
case tok::kw__Nullable:
|
|
case tok::kw__Null_unspecified:
|
|
case tok::kw___kindof:
|
|
return TPResult::True;
|
|
|
|
// Borland
|
|
case tok::kw___pascal:
|
|
return TPResult::True;
|
|
|
|
// AltiVec
|
|
case tok::kw___vector:
|
|
return TPResult::True;
|
|
|
|
case tok::annot_template_id: {
|
|
TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
|
|
if (TemplateId->Kind != TNK_Type_template)
|
|
return TPResult::False;
|
|
CXXScopeSpec SS;
|
|
AnnotateTemplateIdTokenAsType();
|
|
assert(Tok.is(tok::annot_typename));
|
|
goto case_typename;
|
|
}
|
|
|
|
case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
|
|
// We've already annotated a scope; try to annotate a type.
|
|
if (TryAnnotateTypeOrScopeToken())
|
|
return TPResult::Error;
|
|
if (!Tok.is(tok::annot_typename)) {
|
|
// If the next token is an identifier or a type qualifier, then this
|
|
// can't possibly be a valid expression either.
|
|
if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
|
|
CXXScopeSpec SS;
|
|
Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
|
|
Tok.getAnnotationRange(),
|
|
SS);
|
|
if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
|
|
RevertingTentativeParsingAction PA(*this);
|
|
ConsumeAnnotationToken();
|
|
ConsumeToken();
|
|
bool isIdentifier = Tok.is(tok::identifier);
|
|
TPResult TPR = TPResult::False;
|
|
if (!isIdentifier)
|
|
TPR = isCXXDeclarationSpecifier(BracedCastResult,
|
|
HasMissingTypename);
|
|
|
|
if (isIdentifier ||
|
|
TPR == TPResult::True || TPR == TPResult::Error)
|
|
return TPResult::Error;
|
|
|
|
if (HasMissingTypename) {
|
|
// We can't tell whether this is a missing 'typename' or a valid
|
|
// expression.
|
|
*HasMissingTypename = true;
|
|
return TPResult::Ambiguous;
|
|
}
|
|
} else {
|
|
// Try to resolve the name. If it doesn't exist, assume it was
|
|
// intended to name a type and keep disambiguating.
|
|
switch (TryAnnotateName(false /* SS is not dependent */)) {
|
|
case ANK_Error:
|
|
return TPResult::Error;
|
|
case ANK_TentativeDecl:
|
|
return TPResult::False;
|
|
case ANK_TemplateName:
|
|
// In C++17, this could be a type template for class template
|
|
// argument deduction.
|
|
if (getLangOpts().CPlusPlus17) {
|
|
if (TryAnnotateTypeOrScopeToken())
|
|
return TPResult::Error;
|
|
if (Tok.isNot(tok::identifier))
|
|
break;
|
|
}
|
|
|
|
// A bare type template-name which can't be a template template
|
|
// argument is an error, and was probably intended to be a type.
|
|
// In C++17, this could be class template argument deduction.
|
|
return (getLangOpts().CPlusPlus17 || GreaterThanIsOperator)
|
|
? TPResult::True
|
|
: TPResult::False;
|
|
case ANK_Unresolved:
|
|
return HasMissingTypename ? TPResult::Ambiguous
|
|
: TPResult::False;
|
|
case ANK_Success:
|
|
break;
|
|
}
|
|
|
|
// Annotated it, check again.
|
|
assert(Tok.isNot(tok::annot_cxxscope) ||
|
|
NextToken().isNot(tok::identifier));
|
|
return isCXXDeclarationSpecifier(BracedCastResult,
|
|
HasMissingTypename);
|
|
}
|
|
}
|
|
return TPResult::False;
|
|
}
|
|
// If that succeeded, fallthrough into the generic simple-type-id case.
|
|
LLVM_FALLTHROUGH;
|
|
|
|
// The ambiguity resides in a simple-type-specifier/typename-specifier
|
|
// followed by a '('. The '(' could either be the start of:
|
|
//
|
|
// direct-declarator:
|
|
// '(' declarator ')'
|
|
//
|
|
// direct-abstract-declarator:
|
|
// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
|
|
// exception-specification[opt]
|
|
// '(' abstract-declarator ')'
|
|
//
|
|
// or part of a function-style cast expression:
|
|
//
|
|
// simple-type-specifier '(' expression-list[opt] ')'
|
|
//
|
|
|
|
// simple-type-specifier:
|
|
|
|
case tok::annot_typename:
|
|
case_typename:
|
|
// In Objective-C, we might have a protocol-qualified type.
|
|
if (getLangOpts().ObjC1 && NextToken().is(tok::less)) {
|
|
// Tentatively parse the protocol qualifiers.
|
|
RevertingTentativeParsingAction PA(*this);
|
|
ConsumeAnyToken(); // The type token
|
|
|
|
TPResult TPR = TryParseProtocolQualifiers();
|
|
bool isFollowedByParen = Tok.is(tok::l_paren);
|
|
bool isFollowedByBrace = Tok.is(tok::l_brace);
|
|
|
|
if (TPR == TPResult::Error)
|
|
return TPResult::Error;
|
|
|
|
if (isFollowedByParen)
|
|
return TPResult::Ambiguous;
|
|
|
|
if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
|
|
return BracedCastResult;
|
|
|
|
return TPResult::True;
|
|
}
|
|
LLVM_FALLTHROUGH;
|
|
|
|
case tok::kw_char:
|
|
case tok::kw_wchar_t:
|
|
case tok::kw_char16_t:
|
|
case tok::kw_char32_t:
|
|
case tok::kw_bool:
|
|
case tok::kw_short:
|
|
case tok::kw_int:
|
|
case tok::kw_long:
|
|
case tok::kw___int64:
|
|
case tok::kw___int128:
|
|
case tok::kw_signed:
|
|
case tok::kw_unsigned:
|
|
case tok::kw_half:
|
|
case tok::kw_float:
|
|
case tok::kw_double:
|
|
case tok::kw__Float16:
|
|
case tok::kw___float128:
|
|
case tok::kw_void:
|
|
case tok::annot_decltype:
|
|
if (NextToken().is(tok::l_paren))
|
|
return TPResult::Ambiguous;
|
|
|
|
// This is a function-style cast in all cases we disambiguate other than
|
|
// one:
|
|
// struct S {
|
|
// enum E : int { a = 4 }; // enum
|
|
// enum E : int { 4 }; // bit-field
|
|
// };
|
|
if (getLangOpts().CPlusPlus11 && NextToken().is(tok::l_brace))
|
|
return BracedCastResult;
|
|
|
|
if (isStartOfObjCClassMessageMissingOpenBracket())
|
|
return TPResult::False;
|
|
|
|
return TPResult::True;
|
|
|
|
// GNU typeof support.
|
|
case tok::kw_typeof: {
|
|
if (NextToken().isNot(tok::l_paren))
|
|
return TPResult::True;
|
|
|
|
RevertingTentativeParsingAction PA(*this);
|
|
|
|
TPResult TPR = TryParseTypeofSpecifier();
|
|
bool isFollowedByParen = Tok.is(tok::l_paren);
|
|
bool isFollowedByBrace = Tok.is(tok::l_brace);
|
|
|
|
if (TPR == TPResult::Error)
|
|
return TPResult::Error;
|
|
|
|
if (isFollowedByParen)
|
|
return TPResult::Ambiguous;
|
|
|
|
if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
|
|
return BracedCastResult;
|
|
|
|
return TPResult::True;
|
|
}
|
|
|
|
// C++0x type traits support
|
|
case tok::kw___underlying_type:
|
|
return TPResult::True;
|
|
|
|
// C11 _Atomic
|
|
case tok::kw__Atomic:
|
|
return TPResult::True;
|
|
|
|
default:
|
|
return TPResult::False;
|
|
}
|
|
}
|
|
|
|
bool Parser::isCXXDeclarationSpecifierAType() {
|
|
switch (Tok.getKind()) {
|
|
// typename-specifier
|
|
case tok::annot_decltype:
|
|
case tok::annot_template_id:
|
|
case tok::annot_typename:
|
|
case tok::kw_typeof:
|
|
case tok::kw___underlying_type:
|
|
return true;
|
|
|
|
// elaborated-type-specifier
|
|
case tok::kw_class:
|
|
case tok::kw_struct:
|
|
case tok::kw_union:
|
|
case tok::kw___interface:
|
|
case tok::kw_enum:
|
|
return true;
|
|
|
|
// simple-type-specifier
|
|
case tok::kw_char:
|
|
case tok::kw_wchar_t:
|
|
case tok::kw_char16_t:
|
|
case tok::kw_char32_t:
|
|
case tok::kw_bool:
|
|
case tok::kw_short:
|
|
case tok::kw_int:
|
|
case tok::kw_long:
|
|
case tok::kw___int64:
|
|
case tok::kw___int128:
|
|
case tok::kw_signed:
|
|
case tok::kw_unsigned:
|
|
case tok::kw_half:
|
|
case tok::kw_float:
|
|
case tok::kw_double:
|
|
case tok::kw__Float16:
|
|
case tok::kw___float128:
|
|
case tok::kw_void:
|
|
case tok::kw___unknown_anytype:
|
|
case tok::kw___auto_type:
|
|
return true;
|
|
|
|
case tok::kw_auto:
|
|
return getLangOpts().CPlusPlus11;
|
|
|
|
case tok::kw__Atomic:
|
|
// "_Atomic foo"
|
|
return NextToken().is(tok::l_paren);
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// [GNU] typeof-specifier:
|
|
/// 'typeof' '(' expressions ')'
|
|
/// 'typeof' '(' type-name ')'
|
|
///
|
|
Parser::TPResult Parser::TryParseTypeofSpecifier() {
|
|
assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
|
|
ConsumeToken();
|
|
|
|
assert(Tok.is(tok::l_paren) && "Expected '('");
|
|
// Parse through the parens after 'typeof'.
|
|
ConsumeParen();
|
|
if (!SkipUntil(tok::r_paren, StopAtSemi))
|
|
return TPResult::Error;
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
/// [ObjC] protocol-qualifiers:
|
|
//// '<' identifier-list '>'
|
|
Parser::TPResult Parser::TryParseProtocolQualifiers() {
|
|
assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
|
|
ConsumeToken();
|
|
do {
|
|
if (Tok.isNot(tok::identifier))
|
|
return TPResult::Error;
|
|
ConsumeToken();
|
|
|
|
if (Tok.is(tok::comma)) {
|
|
ConsumeToken();
|
|
continue;
|
|
}
|
|
|
|
if (Tok.is(tok::greater)) {
|
|
ConsumeToken();
|
|
return TPResult::Ambiguous;
|
|
}
|
|
} while (false);
|
|
|
|
return TPResult::Error;
|
|
}
|
|
|
|
/// isCXXFunctionDeclarator - Disambiguates between a function declarator or
|
|
/// a constructor-style initializer, when parsing declaration statements.
|
|
/// Returns true for function declarator and false for constructor-style
|
|
/// initializer.
|
|
/// If during the disambiguation process a parsing error is encountered,
|
|
/// the function returns true to let the declaration parsing code handle it.
|
|
///
|
|
/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
|
|
/// exception-specification[opt]
|
|
///
|
|
bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
|
|
|
|
// C++ 8.2p1:
|
|
// The ambiguity arising from the similarity between a function-style cast and
|
|
// a declaration mentioned in 6.8 can also occur in the context of a
|
|
// declaration. In that context, the choice is between a function declaration
|
|
// with a redundant set of parentheses around a parameter name and an object
|
|
// declaration with a function-style cast as the initializer. Just as for the
|
|
// ambiguities mentioned in 6.8, the resolution is to consider any construct
|
|
// that could possibly be a declaration a declaration.
|
|
|
|
RevertingTentativeParsingAction PA(*this);
|
|
|
|
ConsumeParen();
|
|
bool InvalidAsDeclaration = false;
|
|
TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
|
|
if (TPR == TPResult::Ambiguous) {
|
|
if (Tok.isNot(tok::r_paren))
|
|
TPR = TPResult::False;
|
|
else {
|
|
const Token &Next = NextToken();
|
|
if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
|
|
tok::kw_throw, tok::kw_noexcept, tok::l_square,
|
|
tok::l_brace, tok::kw_try, tok::equal, tok::arrow) ||
|
|
isCXX11VirtSpecifier(Next))
|
|
// The next token cannot appear after a constructor-style initializer,
|
|
// and can appear next in a function definition. This must be a function
|
|
// declarator.
|
|
TPR = TPResult::True;
|
|
else if (InvalidAsDeclaration)
|
|
// Use the absence of 'typename' as a tie-breaker.
|
|
TPR = TPResult::False;
|
|
}
|
|
}
|
|
|
|
if (IsAmbiguous && TPR == TPResult::Ambiguous)
|
|
*IsAmbiguous = true;
|
|
|
|
// In case of an error, let the declaration parsing code handle it.
|
|
return TPR != TPResult::False;
|
|
}
|
|
|
|
/// parameter-declaration-clause:
|
|
/// parameter-declaration-list[opt] '...'[opt]
|
|
/// parameter-declaration-list ',' '...'
|
|
///
|
|
/// parameter-declaration-list:
|
|
/// parameter-declaration
|
|
/// parameter-declaration-list ',' parameter-declaration
|
|
///
|
|
/// parameter-declaration:
|
|
/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
|
|
/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
|
|
/// '=' assignment-expression
|
|
/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
|
|
/// attributes[opt]
|
|
/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
|
|
/// attributes[opt] '=' assignment-expression
|
|
///
|
|
Parser::TPResult
|
|
Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
|
|
bool VersusTemplateArgument) {
|
|
|
|
if (Tok.is(tok::r_paren))
|
|
return TPResult::Ambiguous;
|
|
|
|
// parameter-declaration-list[opt] '...'[opt]
|
|
// parameter-declaration-list ',' '...'
|
|
//
|
|
// parameter-declaration-list:
|
|
// parameter-declaration
|
|
// parameter-declaration-list ',' parameter-declaration
|
|
//
|
|
while (1) {
|
|
// '...'[opt]
|
|
if (Tok.is(tok::ellipsis)) {
|
|
ConsumeToken();
|
|
if (Tok.is(tok::r_paren))
|
|
return TPResult::True; // '...)' is a sign of a function declarator.
|
|
else
|
|
return TPResult::False;
|
|
}
|
|
|
|
// An attribute-specifier-seq here is a sign of a function declarator.
|
|
if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
|
|
/*OuterMightBeMessageSend*/true))
|
|
return TPResult::True;
|
|
|
|
ParsedAttributes attrs(AttrFactory);
|
|
MaybeParseMicrosoftAttributes(attrs);
|
|
|
|
// decl-specifier-seq
|
|
// A parameter-declaration's initializer must be preceded by an '=', so
|
|
// decl-specifier-seq '{' is not a parameter in C++11.
|
|
TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
|
|
InvalidAsDeclaration);
|
|
|
|
if (VersusTemplateArgument && TPR == TPResult::True) {
|
|
// Consume the decl-specifier-seq. We have to look past it, since a
|
|
// type-id might appear here in a template argument.
|
|
bool SeenType = false;
|
|
do {
|
|
SeenType |= isCXXDeclarationSpecifierAType();
|
|
if (TryConsumeDeclarationSpecifier() == TPResult::Error)
|
|
return TPResult::Error;
|
|
|
|
// If we see a parameter name, this can't be a template argument.
|
|
if (SeenType && Tok.is(tok::identifier))
|
|
return TPResult::True;
|
|
|
|
TPR = isCXXDeclarationSpecifier(TPResult::False,
|
|
InvalidAsDeclaration);
|
|
if (TPR == TPResult::Error)
|
|
return TPR;
|
|
} while (TPR != TPResult::False);
|
|
} else if (TPR == TPResult::Ambiguous) {
|
|
// Disambiguate what follows the decl-specifier.
|
|
if (TryConsumeDeclarationSpecifier() == TPResult::Error)
|
|
return TPResult::Error;
|
|
} else
|
|
return TPR;
|
|
|
|
// declarator
|
|
// abstract-declarator[opt]
|
|
TPR = TryParseDeclarator(true/*mayBeAbstract*/);
|
|
if (TPR != TPResult::Ambiguous)
|
|
return TPR;
|
|
|
|
// [GNU] attributes[opt]
|
|
if (Tok.is(tok::kw___attribute))
|
|
return TPResult::True;
|
|
|
|
// If we're disambiguating a template argument in a default argument in
|
|
// a class definition versus a parameter declaration, an '=' here
|
|
// disambiguates the parse one way or the other.
|
|
// If this is a parameter, it must have a default argument because
|
|
// (a) the previous parameter did, and
|
|
// (b) this must be the first declaration of the function, so we can't
|
|
// inherit any default arguments from elsewhere.
|
|
// If we see an ')', then we've reached the end of a
|
|
// parameter-declaration-clause, and the last param is missing its default
|
|
// argument.
|
|
if (VersusTemplateArgument)
|
|
return Tok.isOneOf(tok::equal, tok::r_paren) ? TPResult::True
|
|
: TPResult::False;
|
|
|
|
if (Tok.is(tok::equal)) {
|
|
// '=' assignment-expression
|
|
// Parse through assignment-expression.
|
|
// FIXME: assignment-expression may contain an unparenthesized comma.
|
|
if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
|
|
return TPResult::Error;
|
|
}
|
|
|
|
if (Tok.is(tok::ellipsis)) {
|
|
ConsumeToken();
|
|
if (Tok.is(tok::r_paren))
|
|
return TPResult::True; // '...)' is a sign of a function declarator.
|
|
else
|
|
return TPResult::False;
|
|
}
|
|
|
|
if (!TryConsumeToken(tok::comma))
|
|
break;
|
|
}
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
/// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
|
|
/// parsing as a function declarator.
|
|
/// If TryParseFunctionDeclarator fully parsed the function declarator, it will
|
|
/// return TPResult::Ambiguous, otherwise it will return either False() or
|
|
/// Error().
|
|
///
|
|
/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
|
|
/// exception-specification[opt]
|
|
///
|
|
/// exception-specification:
|
|
/// 'throw' '(' type-id-list[opt] ')'
|
|
///
|
|
Parser::TPResult Parser::TryParseFunctionDeclarator() {
|
|
|
|
// The '(' is already parsed.
|
|
|
|
TPResult TPR = TryParseParameterDeclarationClause();
|
|
if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
|
|
TPR = TPResult::False;
|
|
|
|
if (TPR == TPResult::False || TPR == TPResult::Error)
|
|
return TPR;
|
|
|
|
// Parse through the parens.
|
|
if (!SkipUntil(tok::r_paren, StopAtSemi))
|
|
return TPResult::Error;
|
|
|
|
// cv-qualifier-seq
|
|
while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw___unaligned,
|
|
tok::kw_restrict))
|
|
ConsumeToken();
|
|
|
|
// ref-qualifier[opt]
|
|
if (Tok.isOneOf(tok::amp, tok::ampamp))
|
|
ConsumeToken();
|
|
|
|
// exception-specification
|
|
if (Tok.is(tok::kw_throw)) {
|
|
ConsumeToken();
|
|
if (Tok.isNot(tok::l_paren))
|
|
return TPResult::Error;
|
|
|
|
// Parse through the parens after 'throw'.
|
|
ConsumeParen();
|
|
if (!SkipUntil(tok::r_paren, StopAtSemi))
|
|
return TPResult::Error;
|
|
}
|
|
if (Tok.is(tok::kw_noexcept)) {
|
|
ConsumeToken();
|
|
// Possibly an expression as well.
|
|
if (Tok.is(tok::l_paren)) {
|
|
// Find the matching rparen.
|
|
ConsumeParen();
|
|
if (!SkipUntil(tok::r_paren, StopAtSemi))
|
|
return TPResult::Error;
|
|
}
|
|
}
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|
|
|
|
/// '[' constant-expression[opt] ']'
|
|
///
|
|
Parser::TPResult Parser::TryParseBracketDeclarator() {
|
|
ConsumeBracket();
|
|
if (!SkipUntil(tok::r_square, StopAtSemi))
|
|
return TPResult::Error;
|
|
|
|
return TPResult::Ambiguous;
|
|
}
|