mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-27 09:46:06 +00:00
732bccb8c1
This patch replaces uses of StringRef::{starts,ends}with with
StringRef::{starts,ends}_with for consistency with
std::{string,string_view}::{starts,ends}_with in C++20.
I'm planning to deprecate and eventually remove
StringRef::{starts,ends}with.
453 lines
18 KiB
C++
453 lines
18 KiB
C++
//===--- CXX.cpp - Define public interfaces for C++ grammar ---------------===//
|
||
//
|
||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||
// See https://llvm.org/LICENSE.txt for license information.
|
||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#include "clang-pseudo/cxx/CXX.h"
|
||
#include "clang-pseudo/Forest.h"
|
||
#include "clang-pseudo/Language.h"
|
||
#include "clang-pseudo/grammar/Grammar.h"
|
||
#include "clang-pseudo/grammar/LRTable.h"
|
||
#include "clang/Basic/CharInfo.h"
|
||
#include "clang/Basic/TokenKinds.h"
|
||
#include "llvm/ADT/StringSwitch.h"
|
||
#include "llvm/Support/Debug.h"
|
||
#include <utility>
|
||
#define DEBUG_TYPE "CXX.cpp"
|
||
|
||
namespace clang {
|
||
namespace pseudo {
|
||
namespace cxx {
|
||
namespace {
|
||
static const char *CXXBNF =
|
||
#include "CXXBNF.inc"
|
||
;
|
||
|
||
// User-defined string literals look like `""suffix`.
|
||
bool isStringUserDefined(const Token &Tok) {
|
||
return !Tok.text().ends_with("\"");
|
||
}
|
||
bool isCharUserDefined(const Token &Tok) { return !Tok.text().ends_with("'"); }
|
||
|
||
// Combinable flags describing numbers.
|
||
// Clang has just one numeric_token kind, the grammar has 4.
|
||
enum NumericKind {
|
||
Integer = 0,
|
||
Floating = 1 << 0,
|
||
UserDefined = 1 << 1,
|
||
};
|
||
// Determine the kind of numeric_constant we have.
|
||
// We can assume it's something valid, as it has been lexed.
|
||
// FIXME: is this expensive enough that we should set flags on the token
|
||
// and reuse them rather than computing it for each guard?
|
||
unsigned numKind(const Token &Tok) {
|
||
assert(Tok.Kind == tok::numeric_constant);
|
||
llvm::StringRef Text = Tok.text();
|
||
if (Text.size() <= 1)
|
||
return Integer;
|
||
bool Hex =
|
||
Text.size() > 2 && Text[0] == '0' && (Text[1] == 'x' || Text[1] == 'X');
|
||
uint8_t K = Integer;
|
||
|
||
for (char C : Text) {
|
||
switch (C) {
|
||
case '.':
|
||
K |= Floating;
|
||
break;
|
||
case 'e':
|
||
case 'E':
|
||
if (!Hex)
|
||
K |= Floating;
|
||
break;
|
||
case 'p':
|
||
case 'P':
|
||
if (Hex)
|
||
K |= Floating;
|
||
break;
|
||
case '_':
|
||
K |= UserDefined;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
// We would be done here, but there are stdlib UDLs that lack _.
|
||
// We must distinguish these from the builtin suffixes.
|
||
unsigned LastLetter = Text.size();
|
||
while (LastLetter > 0 && isLetter(Text[LastLetter - 1]))
|
||
--LastLetter;
|
||
if (LastLetter == Text.size()) // Common case
|
||
return NumericKind(K);
|
||
// Trailing d/e/f are not part of the suffix in hex numbers.
|
||
while (Hex && LastLetter < Text.size() && isHexDigit(Text[LastLetter]))
|
||
++LastLetter;
|
||
return llvm::StringSwitch<int, unsigned>(Text.substr(LastLetter))
|
||
// std::chrono
|
||
.Cases("h", "min", "s", "ms", "us", "ns", "d", "y", K | UserDefined)
|
||
// complex
|
||
.Cases("il", "i", "if", K | UserDefined)
|
||
.Default(K);
|
||
}
|
||
|
||
// RHS is expected to contain a single terminal.
|
||
// Returns the corresponding token.
|
||
const Token &onlyToken(tok::TokenKind Kind,
|
||
const ArrayRef<const ForestNode *> RHS,
|
||
const TokenStream &Tokens) {
|
||
assert(RHS.size() == 1 && RHS.front()->symbol() == tokenSymbol(Kind));
|
||
return Tokens.tokens()[RHS.front()->startTokenIndex()];
|
||
}
|
||
// RHS is expected to contain a single symbol.
|
||
// Returns the corresponding ForestNode.
|
||
const ForestNode &onlySymbol(SymbolID Kind,
|
||
const ArrayRef<const ForestNode *> RHS,
|
||
const TokenStream &Tokens) {
|
||
assert(RHS.size() == 1 && RHS.front()->symbol() == Kind);
|
||
return *RHS.front();
|
||
}
|
||
|
||
bool isFunctionDeclarator(const ForestNode *Declarator) {
|
||
assert(Declarator->symbol() == cxx::Symbol::declarator);
|
||
bool IsFunction = false;
|
||
while (true) {
|
||
// not well-formed code, return the best guess.
|
||
if (Declarator->kind() != ForestNode::Sequence)
|
||
return IsFunction;
|
||
|
||
switch (Declarator->rule()) {
|
||
case rule::noptr_declarator::declarator_id: // reached the bottom
|
||
return IsFunction;
|
||
// *X is a nonfunction (unless X is a function).
|
||
case rule::ptr_declarator::ptr_operator__ptr_declarator:
|
||
Declarator = Declarator->elements()[1];
|
||
IsFunction = false;
|
||
continue;
|
||
// X() is a function (unless X is a pointer or similar).
|
||
case rule::declarator::
|
||
noptr_declarator__parameters_and_qualifiers__trailing_return_type:
|
||
case rule::noptr_declarator::noptr_declarator__parameters_and_qualifiers:
|
||
Declarator = Declarator->elements()[0];
|
||
IsFunction = true;
|
||
continue;
|
||
// X[] is an array (unless X is a pointer or function).
|
||
case rule::noptr_declarator::
|
||
noptr_declarator__L_SQUARE__constant_expression__R_SQUARE:
|
||
case rule::noptr_declarator::noptr_declarator__L_SQUARE__R_SQUARE:
|
||
Declarator = Declarator->elements()[0];
|
||
IsFunction = false;
|
||
continue;
|
||
// (X) is whatever X is.
|
||
case rule::noptr_declarator::L_PAREN__ptr_declarator__R_PAREN:
|
||
Declarator = Declarator->elements()[1];
|
||
continue;
|
||
case rule::ptr_declarator::noptr_declarator:
|
||
case rule::declarator::ptr_declarator:
|
||
Declarator = Declarator->elements()[0];
|
||
continue;
|
||
|
||
default:
|
||
assert(false && "unhandled declarator for IsFunction");
|
||
return IsFunction;
|
||
}
|
||
}
|
||
llvm_unreachable("unreachable");
|
||
}
|
||
|
||
bool guardNextTokenNotElse(const GuardParams &P) {
|
||
return symbolToToken(P.Lookahead) != tok::kw_else;
|
||
}
|
||
|
||
bool specifiesStructuredBinding(const GuardParams &P) {
|
||
const auto DSS = P.RHS[0];
|
||
assert(DSS->symbol() == Symbol::decl_specifier_seq);
|
||
|
||
auto Length = P.RHS[1]->startTokenIndex() - DSS->startTokenIndex();
|
||
for (const auto &T :
|
||
P.Tokens.tokens().slice(DSS->startTokenIndex(), Length)) {
|
||
switch (T.Kind) {
|
||
case clang::tok::kw_static:
|
||
case clang::tok::kw_thread_local:
|
||
case clang::tok::kw_auto:
|
||
case clang::tok::kw_const:
|
||
case clang::tok::kw_volatile:
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// Whether this e.g. decl-specifier contains an "exclusive" type such as a class
|
||
// name, and thus can't combine with a second exclusive type.
|
||
//
|
||
// Returns false for
|
||
// - non-types
|
||
// - "unsigned" etc that may suffice as types but may modify others
|
||
// - cases of uncertainty (e.g. due to ambiguity)
|
||
bool hasExclusiveType(const ForestNode *N) {
|
||
// FIXME: every time we apply this check, we walk the whole subtree.
|
||
// Add per-node caching instead.
|
||
while (true) {
|
||
assert(N->symbol() == Symbol::decl_specifier_seq ||
|
||
N->symbol() == Symbol::type_specifier_seq ||
|
||
N->symbol() == Symbol::defining_type_specifier_seq ||
|
||
N->symbol() == Symbol::decl_specifier ||
|
||
N->symbol() == Symbol::type_specifier ||
|
||
N->symbol() == Symbol::defining_type_specifier ||
|
||
N->symbol() == Symbol::simple_type_specifier);
|
||
if (N->kind() == ForestNode::Opaque)
|
||
return false; // conservative
|
||
if (N->kind() == ForestNode::Ambiguous)
|
||
return llvm::all_of(N->alternatives(), hasExclusiveType); // conservative
|
||
// All supported symbols are nonterminals.
|
||
assert(N->kind() == ForestNode::Sequence);
|
||
switch (N->rule()) {
|
||
// seq := element seq: check element then continue into seq
|
||
case rule::decl_specifier_seq::decl_specifier__decl_specifier_seq:
|
||
case rule::defining_type_specifier_seq::defining_type_specifier__defining_type_specifier_seq:
|
||
case rule::type_specifier_seq::type_specifier__type_specifier_seq:
|
||
if (hasExclusiveType(N->children()[0]))
|
||
return true;
|
||
N = N->children()[1];
|
||
continue;
|
||
// seq := element: continue into element
|
||
case rule::decl_specifier_seq::decl_specifier:
|
||
case rule::type_specifier_seq::type_specifier:
|
||
case rule::defining_type_specifier_seq::defining_type_specifier:
|
||
N = N->children()[0];
|
||
continue;
|
||
|
||
// defining-type-specifier
|
||
case rule::defining_type_specifier::type_specifier:
|
||
N = N->children()[0];
|
||
continue;
|
||
case rule::defining_type_specifier::class_specifier:
|
||
case rule::defining_type_specifier::enum_specifier:
|
||
return true;
|
||
|
||
// decl-specifier
|
||
case rule::decl_specifier::defining_type_specifier:
|
||
N = N->children()[0];
|
||
continue;
|
||
case rule::decl_specifier::CONSTEVAL:
|
||
case rule::decl_specifier::CONSTEXPR:
|
||
case rule::decl_specifier::CONSTINIT:
|
||
case rule::decl_specifier::INLINE:
|
||
case rule::decl_specifier::FRIEND:
|
||
case rule::decl_specifier::storage_class_specifier:
|
||
case rule::decl_specifier::TYPEDEF:
|
||
case rule::decl_specifier::function_specifier:
|
||
return false;
|
||
|
||
// type-specifier
|
||
case rule::type_specifier::elaborated_type_specifier:
|
||
case rule::type_specifier::typename_specifier:
|
||
return true;
|
||
case rule::type_specifier::simple_type_specifier:
|
||
N = N->children()[0];
|
||
continue;
|
||
case rule::type_specifier::cv_qualifier:
|
||
return false;
|
||
|
||
// simple-type-specifier
|
||
case rule::simple_type_specifier::type_name:
|
||
case rule::simple_type_specifier::template_name:
|
||
case rule::simple_type_specifier::builtin_type:
|
||
case rule::simple_type_specifier::nested_name_specifier__TEMPLATE__simple_template_id:
|
||
case rule::simple_type_specifier::nested_name_specifier__template_name:
|
||
case rule::simple_type_specifier::nested_name_specifier__type_name:
|
||
case rule::simple_type_specifier::decltype_specifier:
|
||
case rule::simple_type_specifier::placeholder_type_specifier:
|
||
return true;
|
||
case rule::simple_type_specifier::LONG:
|
||
case rule::simple_type_specifier::SHORT:
|
||
case rule::simple_type_specifier::SIGNED:
|
||
case rule::simple_type_specifier::UNSIGNED:
|
||
return false;
|
||
|
||
default:
|
||
LLVM_DEBUG(llvm::errs() << "Unhandled rule " << N->rule() << "\n");
|
||
llvm_unreachable("hasExclusiveType be exhaustive!");
|
||
}
|
||
}
|
||
}
|
||
|
||
llvm::DenseMap<ExtensionID, RuleGuard> buildGuards() {
|
||
#define GUARD(cond) \
|
||
{ \
|
||
[](const GuardParams &P) { return cond; } \
|
||
}
|
||
#define TOKEN_GUARD(kind, cond) \
|
||
[](const GuardParams& P) { \
|
||
const Token &Tok = onlyToken(tok::kind, P.RHS, P.Tokens); \
|
||
return cond; \
|
||
}
|
||
#define SYMBOL_GUARD(kind, cond) \
|
||
[](const GuardParams& P) { \
|
||
const ForestNode &N = onlySymbol(Symbol::kind, P.RHS, P.Tokens); \
|
||
return cond; \
|
||
}
|
||
return {
|
||
{rule::function_declarator::declarator,
|
||
SYMBOL_GUARD(declarator, isFunctionDeclarator(&N))},
|
||
{rule::non_function_declarator::declarator,
|
||
SYMBOL_GUARD(declarator, !isFunctionDeclarator(&N))},
|
||
|
||
// A {decl,type,defining-type}-specifier-sequence cannot have multiple
|
||
// "exclusive" types (like class names): a value has only one type.
|
||
{rule::defining_type_specifier_seq::
|
||
defining_type_specifier__defining_type_specifier_seq,
|
||
GUARD(!hasExclusiveType(P.RHS[0]) || !hasExclusiveType(P.RHS[1]))},
|
||
{rule::type_specifier_seq::type_specifier__type_specifier_seq,
|
||
GUARD(!hasExclusiveType(P.RHS[0]) || !hasExclusiveType(P.RHS[1]))},
|
||
{rule::decl_specifier_seq::decl_specifier__decl_specifier_seq,
|
||
GUARD(!hasExclusiveType(P.RHS[0]) || !hasExclusiveType(P.RHS[1]))},
|
||
|
||
{rule::contextual_override::IDENTIFIER,
|
||
TOKEN_GUARD(identifier, Tok.text() == "override")},
|
||
{rule::contextual_final::IDENTIFIER,
|
||
TOKEN_GUARD(identifier, Tok.text() == "final")},
|
||
{rule::import_keyword::IDENTIFIER,
|
||
TOKEN_GUARD(identifier, Tok.text() == "import")},
|
||
{rule::export_keyword::IDENTIFIER,
|
||
TOKEN_GUARD(identifier, Tok.text() == "export")},
|
||
{rule::module_keyword::IDENTIFIER,
|
||
TOKEN_GUARD(identifier, Tok.text() == "module")},
|
||
{rule::contextual_zero::NUMERIC_CONSTANT,
|
||
TOKEN_GUARD(numeric_constant, Tok.text() == "0")},
|
||
|
||
{rule::selection_statement::IF__L_PAREN__condition__R_PAREN__statement,
|
||
guardNextTokenNotElse},
|
||
{rule::selection_statement::
|
||
IF__L_PAREN__init_statement__condition__R_PAREN__statement,
|
||
guardNextTokenNotElse},
|
||
{rule::selection_statement::
|
||
IF__CONSTEXPR__L_PAREN__condition__R_PAREN__statement,
|
||
guardNextTokenNotElse},
|
||
{rule::selection_statement::
|
||
IF__CONSTEXPR__L_PAREN__init_statement__condition__R_PAREN__statement,
|
||
guardNextTokenNotElse},
|
||
|
||
// Implement C++ [basic.lookup.qual.general]:
|
||
// If a name, template-id, or decltype-specifier is followed by a
|
||
// ::, it shall designate a namespace, class, enumeration, or
|
||
// dependent type, and the :: is never interpreted as a complete
|
||
// nested-name-specifier.
|
||
{rule::nested_name_specifier::COLONCOLON,
|
||
TOKEN_GUARD(coloncolon, Tok.prev().Kind != tok::identifier)},
|
||
|
||
// Implement C++ [dcl.pre#6]:
|
||
// A simple-declaration with an identifier-list is called a structured
|
||
// binding declaration ([dcl.struct.bind]). If the decl-specifier-seq
|
||
// contains any decl-specifier other than static, thread_local, auto,
|
||
// or cv-qualifiers, the program is ill-formed.
|
||
{rule::simple_declaration::
|
||
decl_specifier_seq__ref_qualifier__L_SQUARE__identifier_list__R_SQUARE__initializer__SEMI,
|
||
specifiesStructuredBinding},
|
||
{rule::simple_declaration::
|
||
decl_specifier_seq__L_SQUARE__identifier_list__R_SQUARE__initializer__SEMI,
|
||
specifiesStructuredBinding},
|
||
|
||
// The grammar distinguishes (only) user-defined vs plain string literals,
|
||
// where the clang lexer distinguishes (only) encoding types.
|
||
{rule::user_defined_string_literal_chunk::STRING_LITERAL,
|
||
TOKEN_GUARD(string_literal, isStringUserDefined(Tok))},
|
||
{rule::user_defined_string_literal_chunk::UTF8_STRING_LITERAL,
|
||
TOKEN_GUARD(utf8_string_literal, isStringUserDefined(Tok))},
|
||
{rule::user_defined_string_literal_chunk::UTF16_STRING_LITERAL,
|
||
TOKEN_GUARD(utf16_string_literal, isStringUserDefined(Tok))},
|
||
{rule::user_defined_string_literal_chunk::UTF32_STRING_LITERAL,
|
||
TOKEN_GUARD(utf32_string_literal, isStringUserDefined(Tok))},
|
||
{rule::user_defined_string_literal_chunk::WIDE_STRING_LITERAL,
|
||
TOKEN_GUARD(wide_string_literal, isStringUserDefined(Tok))},
|
||
{rule::string_literal_chunk::STRING_LITERAL,
|
||
TOKEN_GUARD(string_literal, !isStringUserDefined(Tok))},
|
||
{rule::string_literal_chunk::UTF8_STRING_LITERAL,
|
||
TOKEN_GUARD(utf8_string_literal, !isStringUserDefined(Tok))},
|
||
{rule::string_literal_chunk::UTF16_STRING_LITERAL,
|
||
TOKEN_GUARD(utf16_string_literal, !isStringUserDefined(Tok))},
|
||
{rule::string_literal_chunk::UTF32_STRING_LITERAL,
|
||
TOKEN_GUARD(utf32_string_literal, !isStringUserDefined(Tok))},
|
||
{rule::string_literal_chunk::WIDE_STRING_LITERAL,
|
||
TOKEN_GUARD(wide_string_literal, !isStringUserDefined(Tok))},
|
||
// And the same for chars.
|
||
{rule::user_defined_character_literal::CHAR_CONSTANT,
|
||
TOKEN_GUARD(char_constant, isCharUserDefined(Tok))},
|
||
{rule::user_defined_character_literal::UTF8_CHAR_CONSTANT,
|
||
TOKEN_GUARD(utf8_char_constant, isCharUserDefined(Tok))},
|
||
{rule::user_defined_character_literal::UTF16_CHAR_CONSTANT,
|
||
TOKEN_GUARD(utf16_char_constant, isCharUserDefined(Tok))},
|
||
{rule::user_defined_character_literal::UTF32_CHAR_CONSTANT,
|
||
TOKEN_GUARD(utf32_char_constant, isCharUserDefined(Tok))},
|
||
{rule::user_defined_character_literal::WIDE_CHAR_CONSTANT,
|
||
TOKEN_GUARD(wide_char_constant, isCharUserDefined(Tok))},
|
||
{rule::character_literal::CHAR_CONSTANT,
|
||
TOKEN_GUARD(char_constant, !isCharUserDefined(Tok))},
|
||
{rule::character_literal::UTF8_CHAR_CONSTANT,
|
||
TOKEN_GUARD(utf8_char_constant, !isCharUserDefined(Tok))},
|
||
{rule::character_literal::UTF16_CHAR_CONSTANT,
|
||
TOKEN_GUARD(utf16_char_constant, !isCharUserDefined(Tok))},
|
||
{rule::character_literal::UTF32_CHAR_CONSTANT,
|
||
TOKEN_GUARD(utf32_char_constant, !isCharUserDefined(Tok))},
|
||
{rule::character_literal::WIDE_CHAR_CONSTANT,
|
||
TOKEN_GUARD(wide_char_constant, !isCharUserDefined(Tok))},
|
||
// clang just has one NUMERIC_CONSTANT token for {ud,plain}x{float,int}
|
||
{rule::user_defined_integer_literal::NUMERIC_CONSTANT,
|
||
TOKEN_GUARD(numeric_constant, numKind(Tok) == (Integer | UserDefined))},
|
||
{rule::user_defined_floating_point_literal::NUMERIC_CONSTANT,
|
||
TOKEN_GUARD(numeric_constant, numKind(Tok) == (Floating | UserDefined))},
|
||
{rule::integer_literal::NUMERIC_CONSTANT,
|
||
TOKEN_GUARD(numeric_constant, numKind(Tok) == Integer)},
|
||
{rule::floating_point_literal::NUMERIC_CONSTANT,
|
||
TOKEN_GUARD(numeric_constant, numKind(Tok) == Floating)},
|
||
};
|
||
#undef TOKEN_GUARD
|
||
#undef SYMBOL_GUARD
|
||
}
|
||
|
||
Token::Index recoverBrackets(Token::Index Begin, const TokenStream &Tokens) {
|
||
assert(Begin > 0);
|
||
const Token &Left = Tokens.tokens()[Begin - 1];
|
||
assert(Left.Kind == tok::l_brace || Left.Kind == tok::l_paren ||
|
||
Left.Kind == tok::l_square);
|
||
if (const Token *Right = Left.pair()) {
|
||
assert(Tokens.index(*Right) > Begin - 1);
|
||
return Tokens.index(*Right);
|
||
}
|
||
return Token::Invalid;
|
||
}
|
||
|
||
llvm::DenseMap<ExtensionID, RecoveryStrategy> buildRecoveryStrategies() {
|
||
return {
|
||
{Extension::Brackets, recoverBrackets},
|
||
};
|
||
}
|
||
|
||
} // namespace
|
||
|
||
const Language &getLanguage() {
|
||
static const auto &CXXLanguage = []() -> const Language & {
|
||
std::vector<std::string> Diags;
|
||
auto G = Grammar::parseBNF(CXXBNF, Diags);
|
||
assert(Diags.empty());
|
||
LRTable Table = LRTable::buildSLR(G);
|
||
const Language *PL = new Language{
|
||
std::move(G),
|
||
std::move(Table),
|
||
buildGuards(),
|
||
buildRecoveryStrategies(),
|
||
};
|
||
return *PL;
|
||
}();
|
||
return CXXLanguage;
|
||
}
|
||
|
||
} // namespace cxx
|
||
} // namespace pseudo
|
||
} // namespace clang
|