Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibCpp/Parser.h

201 lines
7.4 KiB
C
Raw Normal View History

LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
/*
* Copyright (c) 2021, Itamar S. <itamar8910@gmail.com>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
*/
#pragma once
#include "AK/NonnullRefPtr.h"
#include "AST.h"
LibCpp: Replace defined preprocessor values when parsing
2021-03-12 17:04:08 +02:00
#include "Preprocessor.h"
LibCpp: Implement Parser::text_in_range using text of tokens It was previously implemented by directly iterating over the program's source.
2021-03-12 15:53:07 +02:00
#include <AK/Noncopyable.h>
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
#include <LibCpp/Lexer.h>
namespace Cpp {
class Parser final {
LibCpp: Replace defined preprocessor values when parsing
2021-03-12 17:04:08 +02:00
AK_MAKE_NONCOPYABLE(Parser);
LibCpp: Implement Parser::text_in_range using text of tokens It was previously implemented by directly iterating over the program's source.
2021-03-12 15:53:07 +02:00
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
public:
LibCpp: Do macro substitution in the preprocessor instead of the parser After this change, the parser is completely separated from preprocessor concepts.
2021-08-06 12:23:20 +03:00
explicit Parser(Vector<Token> tokens, String const& filename);
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
~Parser() = default;
NonnullRefPtr<TranslationUnit> parse();
bool eof() const;
RefPtr<ASTNode> node_at(Position) const;
LibCpp: Remove node_span_size, add index_of_node_at
2021-03-12 15:28:30 +02:00
Optional<size_t> index_of_node_at(Position) const;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
Optional<Token> token_at(Position) const;
LibCpp: Implement Parser::text_in_range using text of tokens It was previously implemented by directly iterating over the program's source.
2021-03-12 15:53:07 +02:00
Optional<size_t> index_of_token_at(Position) const;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
RefPtr<const TranslationUnit> root_node() const { return m_root_node; }
LibCpp: Implement Parser::text_in_range using text of tokens It was previously implemented by directly iterating over the program's source.
2021-03-12 15:53:07 +02:00
String text_of_node(const ASTNode&) const;
LanguageServers/Cpp: Autocomplete declarations from included headers We now also look at the available declarations from included header files when autocompleting names. Additionally, you can now request autocomplete on an empty token, which brings up all available names, starting from the inner-most scope.
2021-02-10 21:48:08 +02:00
StringView text_of_token(const Cpp::Token& token) const;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
void print_tokens() const;
LibCpp: Only store error messages for the main parser state There's no need to store parser error messages for states with depth > 0, as they will eventually be popped from the states stack and their error messages will never be displayed to the user. Profiling shows that this change reduces the % of backtraces that contain the store_state & load_state functions from ~95% to ~70%. Empirically this change reduces the time it takes on my machine for the c++ language server to handle a file that #includes <LibGUI/Widget.h> from ~14sec to ~4sec.
2021-07-13 20:37:28 +03:00
const Vector<String>& errors() const { return m_errors; }
HackStudio: Make TODO entries clickable Now you can click a TODO entry to set focus on that position of that file.
2021-06-01 23:54:55 +02:00
struct TodoEntry {
String content;
String filename;
size_t line { 0 };
size_t column { 0 };
};
Vector<TodoEntry> get_todo_entries() const;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
LibCpp: Add Parser::tokens_in_range(start, end) This function returns the tokens that exist in the specified range.
2021-07-03 11:47:41 +03:00
Vector<Token> tokens_in_range(Position start, Position end) const;
LanguageServers/Cpp: Support jumping to declaration of preprocessor .. definitions.
2021-03-13 10:37:23 +02:00
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
private:
enum class DeclarationType {
Function,
Variable,
Enum,
LibCpp: Support parsing class declarations
2021-04-19 19:41:43 +03:00
Class,
LibCpp: Support non-field class members Previously, we had a special ASTNode for class members, "MemberDeclaration", which only represented fields. This commit removes MemberDeclaration and instead uses regular Declaration nodes for representing the members of a class. This means that we can now also parse methods, inner-classes, and other declarations that appear inside of a class.
2021-06-05 17:57:13 +03:00
Namespace,
LibCpp: Parse basic constructors and destructors
2021-06-07 23:14:26 +03:00
Constructor,
Destructor,
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
};
Optional<DeclarationType> match_declaration_in_translation_unit();
LibCpp: Parse basic constructors and destructors
2021-06-07 23:14:26 +03:00
Optional<Parser::DeclarationType> match_class_member(const StringView& class_name);
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
bool match_function_declaration();
bool match_comment();
bool match_preprocessor();
bool match_whitespace();
bool match_variable_declaration();
bool match_expression();
bool match_secondary_expression();
bool match_enum_declaration();
LibCpp: Support parsing class declarations
2021-04-19 19:41:43 +03:00
bool match_class_declaration();
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
bool match_literal();
bool match_unary_expression();
bool match_boolean_literal();
bool match_keyword(const String&);
bool match_block_statement();
LibCpp: Parse Namespace declaration Also, remove unused State::Context
2021-03-19 21:47:43 +02:00
bool match_namespace_declaration();
LibCpp: Parse templatized types We can now parse things like Vector<int>
2021-03-28 11:55:17 +03:00
bool match_template_arguments();
LibCpp: Add AST::Name A Name node is basically an identifier with an optional scope, e.g Core::File.
2021-03-29 16:52:35 +03:00
bool match_name();
LibCpp: Parse C++ cast expressions parse static_cast, reinterpret_cast, dynamic_cast & const_cast
2021-03-31 22:21:31 +03:00
bool match_cpp_cast_expression();
LibCpp: Parse C-Style parse expressions
2021-04-02 11:29:44 +03:00
bool match_c_style_cast_expression();
LibCpp: Parse sizeof() expression
2021-04-02 10:49:12 +03:00
bool match_sizeof_expression();
LibCpp: Parse braced initialization list
2021-04-02 11:15:22 +03:00
bool match_braced_init_list();
LibCpp: Add TemplatizedName This type represents templatized names, and replaces our previous use of 'TemplatizedType' and 'TemplatizedFunctionCall'. Also, we now parse function calls as secondary expressions.
2021-04-06 19:43:43 +03:00
bool match_type();
LibCpp: Differentiate between Type and NamedType This adds a new ASTNode type called 'NamedType' which inherits from the Type node. Previously every Type node had a name field, but it was not logically accurate. For example, pointer types do not have a name (the pointed-to type may have one).
2021-06-26 15:34:23 +03:00
bool match_named_type();
LibCpp: Handle class access-specifiers in the Parser We can now handle access-specifier tags (for example 'private:') when parsing class declarations. We currently only consume these tags on move on. We'll need to add some logic that accounts for the access level of symbols down the road.
2021-06-06 21:30:53 +03:00
bool match_access_specifier();
LibCpp: Parse basic constructors and destructors
2021-06-07 23:14:26 +03:00
bool match_constructor(const StringView& class_name);
bool match_destructor(const StringView& class_name);
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
Optional<NonnullRefPtrVector<Parameter>> parse_parameter_list(ASTNode& parent);
Optional<Token> consume_whitespace();
void consume_preprocessor();
NonnullRefPtr<Declaration> parse_declaration(ASTNode& parent, DeclarationType);
NonnullRefPtr<FunctionDeclaration> parse_function_declaration(ASTNode& parent);
NonnullRefPtr<FunctionDefinition> parse_function_definition(ASTNode& parent);
NonnullRefPtr<Statement> parse_statement(ASTNode& parent);
LibCpp: Parse templatized types We can now parse things like Vector<int>
2021-03-28 11:55:17 +03:00
NonnullRefPtr<VariableDeclaration> parse_variable_declaration(ASTNode& parent, bool expect_semicolon = true);
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
NonnullRefPtr<Expression> parse_expression(ASTNode& parent);
NonnullRefPtr<Expression> parse_primary_expression(ASTNode& parent);
NonnullRefPtr<Expression> parse_secondary_expression(ASTNode& parent, NonnullRefPtr<Expression> lhs);
NonnullRefPtr<FunctionCall> parse_function_call(ASTNode& parent);
NonnullRefPtr<StringLiteral> parse_string_literal(ASTNode& parent);
NonnullRefPtr<ReturnStatement> parse_return_statement(ASTNode& parent);
NonnullRefPtr<EnumDeclaration> parse_enum_declaration(ASTNode& parent);
LibCpp: Support non-field class members Previously, we had a special ASTNode for class members, "MemberDeclaration", which only represented fields. This commit removes MemberDeclaration and instead uses regular Declaration nodes for representing the members of a class. This means that we can now also parse methods, inner-classes, and other declarations that appear inside of a class.
2021-06-05 17:57:13 +03:00
NonnullRefPtr<StructOrClassDeclaration> parse_class_declaration(ASTNode& parent);
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
NonnullRefPtr<Expression> parse_literal(ASTNode& parent);
NonnullRefPtr<UnaryExpression> parse_unary_expression(ASTNode& parent);
NonnullRefPtr<BooleanLiteral> parse_boolean_literal(ASTNode& parent);
NonnullRefPtr<Type> parse_type(ASTNode& parent);
LibCpp: Differentiate between Type and NamedType This adds a new ASTNode type called 'NamedType' which inherits from the Type node. Previously every Type node had a name field, but it was not logically accurate. For example, pointer types do not have a name (the pointed-to type may have one).
2021-06-26 15:34:23 +03:00
NonnullRefPtr<NamedType> parse_named_type(ASTNode& parent);
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
NonnullRefPtr<BinaryExpression> parse_binary_expression(ASTNode& parent, NonnullRefPtr<Expression> lhs, BinaryOp);
NonnullRefPtr<AssignmentExpression> parse_assignment_expression(ASTNode& parent, NonnullRefPtr<Expression> lhs, AssignmentOp);
NonnullRefPtr<ForStatement> parse_for_statement(ASTNode& parent);
NonnullRefPtr<BlockStatement> parse_block_statement(ASTNode& parent);
NonnullRefPtr<Comment> parse_comment(ASTNode& parent);
LibCpp: Parse If statements
2021-01-29 12:03:02 +02:00
NonnullRefPtr<IfStatement> parse_if_statement(ASTNode& parent);
LibCpp: Parse Namespace declaration Also, remove unused State::Context
2021-03-19 21:47:43 +02:00
NonnullRefPtr<NamespaceDeclaration> parse_namespace_declaration(ASTNode& parent, bool is_nested_namespace = false);
NonnullRefPtrVector<Declaration> parse_declarations_in_translation_unit(ASTNode& parent);
RefPtr<Declaration> parse_single_declaration_in_translation_unit(ASTNode& parent);
LibCpp: Parse templatized types We can now parse things like Vector<int>
2021-03-28 11:55:17 +03:00
NonnullRefPtrVector<Type> parse_template_arguments(ASTNode& parent);
LibCpp: Add AST::Name A Name node is basically an identifier with an optional scope, e.g Core::File.
2021-03-29 16:52:35 +03:00
NonnullRefPtr<Name> parse_name(ASTNode& parent);
LibCpp: Parse C++ cast expressions parse static_cast, reinterpret_cast, dynamic_cast & const_cast
2021-03-31 22:21:31 +03:00
NonnullRefPtr<CppCastExpression> parse_cpp_cast_expression(ASTNode& parent);
LibCpp: Parse sizeof() expression
2021-04-02 10:49:12 +03:00
NonnullRefPtr<SizeofExpression> parse_sizeof_expression(ASTNode& parent);
LibCpp: Parse braced initialization list
2021-04-02 11:15:22 +03:00
NonnullRefPtr<BracedInitList> parse_braced_init_list(ASTNode& parent);
LibCpp: Parse C-Style parse expressions
2021-04-02 11:29:44 +03:00
NonnullRefPtr<CStyleCastExpression> parse_c_style_cast_expression(ASTNode& parent);
LibCpp: Parse basic constructors and destructors
2021-06-07 23:14:26 +03:00
NonnullRefPtrVector<Declaration> parse_class_members(StructOrClassDeclaration& parent);
NonnullRefPtr<Constructor> parse_constructor(ASTNode& parent);
NonnullRefPtr<Destructor> parse_destructor(ASTNode& parent);
LibCpp: Parse Namespace declaration Also, remove unused State::Context
2021-03-19 21:47:43 +02:00
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
bool match(Token::Type);
Token consume(Token::Type);
Token consume();
Token consume_keyword(const String&);
LibCpp: Parse ellipsis We can now parse the printf function declaration :^)
2021-03-01 22:33:46 +02:00
Token peek(size_t offset = 0) const;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
Optional<Token> peek(Token::Type) const;
Position position() const;
LibCpp: Implement Parser::text_in_range using text of tokens It was previously implemented by directly iterating over the program's source.
2021-03-12 15:53:07 +02:00
String text_in_range(Position start, Position end) const;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
void save_state();
void load_state();
struct State {
size_t token_index { 0 };
LibCpp: Don't store entire ASTNode vector in each parser state We previously stored the entire ASTNode vector in each parser state, and this vector was copied whenever a state was loaded or saved. We don't actually need to store the whole nodes list in each state because a new state can only add new nodes to this list, and won't mutate existing nodes. It would suffice to only hold a vector of the nodes that were created while parsing in the current state to keep a reference to them. This reduces the time it takes on my machine for the c++ language server to handle a file that #includes <LibGUI/Widget.h> from ~4sec to ~0.7sec.
2021-07-13 22:07:05 +03:00
NonnullRefPtrVector<ASTNode> state_nodes;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
};
void error(StringView message = {});
template<class T, class... Args>
NonnullRefPtr<T>
create_ast_node(ASTNode& parent, const Position& start, Optional<Position> end, Args&&... args)
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
auto node = adopt_ref(*new T(&parent, start, end, m_filename, forward<Args>(args)...));
LibCpp: Don't store entire ASTNode vector in each parser state We previously stored the entire ASTNode vector in each parser state, and this vector was copied whenever a state was loaded or saved. We don't actually need to store the whole nodes list in each state because a new state can only add new nodes to this list, and won't mutate existing nodes. It would suffice to only hold a vector of the nodes that were created while parsing in the current state to keep a reference to them. This reduces the time it takes on my machine for the c++ language server to handle a file that #includes <LibGUI/Widget.h> from ~4sec to ~0.7sec.
2021-07-13 22:07:05 +03:00
if (m_saved_states.is_empty()) {
m_nodes.append(node);
} else {
m_state.state_nodes.append(node);
LibCpp: Introduce DummyASTNode This allows us to use pase_* methods inside match_* methods, without adding any actual AST nodes to the m_nodes list.
2021-04-02 13:57:52 +03:00
}
LibCpp: Don't store entire ASTNode vector in each parser state We previously stored the entire ASTNode vector in each parser state, and this vector was copied whenever a state was loaded or saved. We don't actually need to store the whole nodes list in each state because a new state can only add new nodes to this list, and won't mutate existing nodes. It would suffice to only hold a vector of the nodes that were created while parsing in the current state to keep a reference to them. This reduces the time it takes on my machine for the c++ language server to handle a file that #includes <LibGUI/Widget.h> from ~4sec to ~0.7sec.
2021-07-13 22:07:05 +03:00
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
return node;
}
NonnullRefPtr<TranslationUnit>
create_root_ast_node(const Position& start, Position end)
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
auto node = adopt_ref(*new TranslationUnit(nullptr, start, end, m_filename));
LibCpp: Don't store entire ASTNode vector in each parser state We previously stored the entire ASTNode vector in each parser state, and this vector was copied whenever a state was loaded or saved. We don't actually need to store the whole nodes list in each state because a new state can only add new nodes to this list, and won't mutate existing nodes. It would suffice to only hold a vector of the nodes that were created while parsing in the current state to keep a reference to them. This reduces the time it takes on my machine for the c++ language server to handle a file that #includes <LibGUI/Widget.h> from ~4sec to ~0.7sec.
2021-07-13 22:07:05 +03:00
m_nodes.append(node);
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
m_root_node = node;
return node;
}
LibCpp: Introduce DummyASTNode This allows us to use pase_* methods inside match_* methods, without adding any actual AST nodes to the m_nodes list.
2021-04-02 13:57:52 +03:00
DummyAstNode& get_dummy_node()
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
static NonnullRefPtr<DummyAstNode> dummy = adopt_ref(*new DummyAstNode(nullptr, {}, {}, {}));
LibCpp: Introduce DummyASTNode This allows us to use pase_* methods inside match_* methods, without adding any actual AST nodes to the m_nodes list.
2021-04-02 13:57:52 +03:00
return dummy;
}
LibCpp: Replace defined preprocessor values when parsing
2021-03-12 17:04:08 +02:00
bool match_attribute_specification();
void consume_attribute_specification();
LibCpp: Handle class access-specifiers in the Parser We can now handle access-specifier tags (for example 'private:') when parsing class declarations. We currently only consume these tags on move on. We'll need to add some logic that accounts for the access level of symbols down the road.
2021-06-06 21:30:53 +03:00
void consume_access_specifier();
LibCpp: Replace defined preprocessor values when parsing
2021-03-12 17:04:08 +02:00
bool match_ellipsis();
Vector<StringView> parse_type_qualifiers();
LibCpp: Support parsing function qualifiers
2021-03-27 19:19:53 +03:00
Vector<StringView> parse_function_qualifiers();
LibCpp: Replace defined preprocessor values when parsing
2021-03-12 17:04:08 +02:00
LibCpp: Parse basic constructors and destructors
2021-06-07 23:14:26 +03:00
enum class CtorOrDtor {
Ctor,
Dtor,
};
void parse_constructor_or_destructor_impl(FunctionDeclaration&, CtorOrDtor);
LibCpp: Store filename in ASTNodes As part of the position information, we now also store the filename the ASTNode belongs to.
2021-02-20 12:23:53 +02:00
String m_filename;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
Vector<Token> m_tokens;
State m_state;
Vector<State> m_saved_states;
RefPtr<TranslationUnit> m_root_node;
LibCpp: Only store error messages for the main parser state There's no need to store parser error messages for states with depth > 0, as they will eventually be popped from the states stack and their error messages will never be displayed to the user. Profiling shows that this change reduces the % of backtraces that contain the store_state & load_state functions from ~95% to ~70%. Empirically this change reduces the time it takes on my machine for the c++ language server to handle a file that #includes <LibGUI/Widget.h> from ~14sec to ~4sec.
2021-07-13 20:37:28 +03:00
Vector<String> m_errors;
LibCpp: Don't store entire ASTNode vector in each parser state We previously stored the entire ASTNode vector in each parser state, and this vector was copied whenever a state was loaded or saved. We don't actually need to store the whole nodes list in each state because a new state can only add new nodes to this list, and won't mutate existing nodes. It would suffice to only hold a vector of the nodes that were created while parsing in the current state to keep a reference to them. This reduces the time it takes on my machine for the c++ language server to handle a file that #includes <LibGUI/Widget.h> from ~4sec to ~0.7sec.
2021-07-13 22:07:05 +03:00
NonnullRefPtrVector<ASTNode> m_nodes;
LibCpp: Add the beginning of a C++ parser This parser will be used by the C++ langauge server to provide better auto-complete (& maybe also other things in the future). It is designed to be error tolerant, and keeps track of the position spans of the AST nodes, which should be useful later for incremental parsing.
2021-01-23 16:47:20 +02:00
};
}
Reference in a new issue Copy permalink