RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 16:17:45 +00:00
Code Issues Activity Actions

LibSQL: Replace Optional<NonnullRefPtr<T>> with RefPtr<T>

Browse source 
We generally don't use Optional with nullable types, since they already
have an empty state, and having multiple empty states is confusing.
This commit is contained in:
Andreas Kling 2021-09-03 12:48:38 +02:00
parent e2c32a6c65
commit 2ef1cd8d12
2 changed files with 59 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

90
Userland/Libraries/LibSQL/AST/Parser.cpp
View file

@ -205,12 +205,12 @@ NonnullRefPtr<Insert> Parser::parse_insert_statement(RefPtr<CommonTableExpressio
if (consume_if(TokenType::Values)) { if (consume_if(TokenType::Values)) {
parse_comma_separated_list(false, [&]() { parse_comma_separated_list(false, [&]() {
if (auto chained_expression = parse_chained_expression(); chained_expression.has_value()) { if (auto chained_expression = parse_chained_expression()) {
auto chained_expr = dynamic_cast<ChainedExpression*>(chained_expression->ptr()); auto chained_expr = dynamic_cast<ChainedExpression*>(chained_expression.ptr());
if ((column_names.size() > 0) && (chained_expr->expressions().size() != column_names.size())) { if ((column_names.size() > 0) && (chained_expr->expressions().size() != column_names.size())) {
syntax_error("Number of expressions does not match number of columns"); syntax_error("Number of expressions does not match number of columns");
} else { } else {
chained_expressions.append(move(chained_expression.value())); chained_expressions.append(chained_expression.release_nonnull());
} }
} else { } else {
expected("Chained expression"); expected("Chained expression");
@ -398,26 +398,26 @@ NonnullRefPtr<Expression> Parser::parse_expression()
NonnullRefPtr<Expression> Parser::parse_primary_expression() NonnullRefPtr<Expression> Parser::parse_primary_expression()
{ {
if (auto expression = parse_literal_value_expression(); expression.has_value()) if (auto expression = parse_literal_value_expression())
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_column_name_expression(); expression.has_value()) if (auto expression = parse_column_name_expression())
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_unary_operator_expression(); expression.has_value()) if (auto expression = parse_unary_operator_expression())
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_chained_expression(); expression.has_value()) if (auto expression = parse_chained_expression())
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_cast_expression(); expression.has_value()) if (auto expression = parse_cast_expression())
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_case_expression(); expression.has_value()) if (auto expression = parse_case_expression())
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_exists_expression(false); expression.has_value()) if (auto expression = parse_exists_expression(false))
return move(expression.value()); return expression.release_nonnull();
expected("Primary Expression"); expected("Primary Expression");
consume(); consume();
@ -427,30 +427,30 @@ NonnullRefPtr<Expression> Parser::parse_primary_expression()
NonnullRefPtr<Expression> Parser::parse_secondary_expression(NonnullRefPtr<Expression> primary) NonnullRefPtr<Expression> Parser::parse_secondary_expression(NonnullRefPtr<Expression> primary)
{ {
if (auto expression = parse_binary_operator_expression(primary); expression.has_value()) if (auto expression = parse_binary_operator_expression(primary))
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_collate_expression(primary); expression.has_value()) if (auto expression = parse_collate_expression(primary))
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_is_expression(primary); expression.has_value()) if (auto expression = parse_is_expression(primary))
return move(expression.value()); return expression.release_nonnull();
bool invert_expression = false; bool invert_expression = false;
if (consume_if(TokenType::Not)) if (consume_if(TokenType::Not))
invert_expression = true; invert_expression = true;
if (auto expression = parse_match_expression(primary, invert_expression); expression.has_value()) if (auto expression = parse_match_expression(primary, invert_expression))
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_null_expression(primary, invert_expression); expression.has_value()) if (auto expression = parse_null_expression(primary, invert_expression))
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_between_expression(primary, invert_expression); expression.has_value()) if (auto expression = parse_between_expression(primary, invert_expression))
return move(expression.value()); return expression.release_nonnull();
if (auto expression = parse_in_expression(primary, invert_expression); expression.has_value()) if (auto expression = parse_in_expression(primary, invert_expression))
return move(expression.value()); return expression.release_nonnull();
expected("Secondary Expression"); expected("Secondary Expression");
consume(); consume();
@ -493,7 +493,7 @@ bool Parser::match_secondary_expression() const
|| match(TokenType::In); || match(TokenType::In);
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_literal_value_expression() RefPtr<Expression> Parser::parse_literal_value_expression()
{ {
if (match(TokenType::NumericLiteral)) { if (match(TokenType::NumericLiteral)) {
auto value = consume().double_value(); auto value = consume().double_value();
@ -515,7 +515,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_literal_value_expression()
return {}; return {};
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_column_name_expression(String with_parsed_identifier, bool with_parsed_period) RefPtr<Expression> Parser::parse_column_name_expression(String with_parsed_identifier, bool with_parsed_period)
{ {
if (with_parsed_identifier.is_null() && !match(TokenType::Identifier)) if (with_parsed_identifier.is_null() && !match(TokenType::Identifier))
return {}; return {};
@ -548,7 +548,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_column_name_expression(String
return create_ast_node<ColumnNameExpression>(move(schema_name), move(table_name), move(column_name)); return create_ast_node<ColumnNameExpression>(move(schema_name), move(table_name), move(column_name));
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_unary_operator_expression() RefPtr<Expression> Parser::parse_unary_operator_expression()
{ {
if (consume_if(TokenType::Minus)) if (consume_if(TokenType::Minus))
return create_ast_node<UnaryOperatorExpression>(UnaryOperator::Minus, parse_expression()); return create_ast_node<UnaryOperatorExpression>(UnaryOperator::Minus, parse_expression());
@ -569,7 +569,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_unary_operator_expression()
return {}; return {};
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_binary_operator_expression(NonnullRefPtr<Expression> lhs) RefPtr<Expression> Parser::parse_binary_operator_expression(NonnullRefPtr<Expression> lhs)
{ {
if (consume_if(TokenType::DoublePipe)) if (consume_if(TokenType::DoublePipe))
return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Concatenate, move(lhs), parse_expression()); return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Concatenate, move(lhs), parse_expression());
@ -628,7 +628,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_binary_operator_expression(Non
return {}; return {};
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_chained_expression() RefPtr<Expression> Parser::parse_chained_expression()
{ {
if (!consume_if(TokenType::ParenOpen)) if (!consume_if(TokenType::ParenOpen))
return {}; return {};
@ -643,7 +643,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_chained_expression()
return create_ast_node<ChainedExpression>(move(expressions)); return create_ast_node<ChainedExpression>(move(expressions));
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_cast_expression() RefPtr<Expression> Parser::parse_cast_expression()
{ {
if (!match(TokenType::Cast)) if (!match(TokenType::Cast))
return {}; return {};
@ -658,7 +658,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_cast_expression()
return create_ast_node<CastExpression>(move(expression), move(type_name)); return create_ast_node<CastExpression>(move(expression), move(type_name));
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_case_expression() RefPtr<Expression> Parser::parse_case_expression()
{ {
if (!match(TokenType::Case)) if (!match(TokenType::Case))
return {}; return {};
@ -692,7 +692,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_case_expression()
return create_ast_node<CaseExpression>(move(case_expression), move(when_then_clauses), move(else_expression)); return create_ast_node<CaseExpression>(move(case_expression), move(when_then_clauses), move(else_expression));
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_exists_expression(bool invert_expression, TokenType opening_token) RefPtr<Expression> Parser::parse_exists_expression(bool invert_expression, TokenType opening_token)
{ {
VERIFY((opening_token == TokenType::Exists) || (opening_token == TokenType::Select)); VERIFY((opening_token == TokenType::Exists) || (opening_token == TokenType::Select));
@ -707,7 +707,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_exists_expression(bool invert_
return create_ast_node<ExistsExpression>(move(select_statement), invert_expression); return create_ast_node<ExistsExpression>(move(select_statement), invert_expression);
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_collate_expression(NonnullRefPtr<Expression> expression) RefPtr<Expression> Parser::parse_collate_expression(NonnullRefPtr<Expression> expression)
{ {
if (!match(TokenType::Collate)) if (!match(TokenType::Collate))
return {}; return {};
@ -718,7 +718,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_collate_expression(NonnullRefP
return create_ast_node<CollateExpression>(move(expression), move(collation_name)); return create_ast_node<CollateExpression>(move(expression), move(collation_name));
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_is_expression(NonnullRefPtr<Expression> expression) RefPtr<Expression> Parser::parse_is_expression(NonnullRefPtr<Expression> expression)
{ {
if (!match(TokenType::Is)) if (!match(TokenType::Is))
return {}; return {};
@ -735,7 +735,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_is_expression(NonnullRefPtr<Ex
return create_ast_node<IsExpression>(move(expression), move(rhs), invert_expression); return create_ast_node<IsExpression>(move(expression), move(rhs), invert_expression);
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_match_expression(NonnullRefPtr<Expression> lhs, bool invert_expression) RefPtr<Expression> Parser::parse_match_expression(NonnullRefPtr<Expression> lhs, bool invert_expression)
{ {
auto parse_escape = [this]() { auto parse_escape = [this]() {
RefPtr<Expression> escape; RefPtr<Expression> escape;
@ -759,7 +759,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_match_expression(NonnullRefPtr
return {}; return {};
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_null_expression(NonnullRefPtr<Expression> expression, bool invert_expression) RefPtr<Expression> Parser::parse_null_expression(NonnullRefPtr<Expression> expression, bool invert_expression)
{ {
if (!match(TokenType::Isnull) && !match(TokenType::Notnull) && !(invert_expression && match(TokenType::Null))) if (!match(TokenType::Isnull) && !match(TokenType::Notnull) && !(invert_expression && match(TokenType::Null)))
return {}; return {};
@ -770,7 +770,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_null_expression(NonnullRefPtr<
return create_ast_node<NullExpression>(move(expression), invert_expression); return create_ast_node<NullExpression>(move(expression), invert_expression);
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_between_expression(NonnullRefPtr<Expression> expression, bool invert_expression) RefPtr<Expression> Parser::parse_between_expression(NonnullRefPtr<Expression> expression, bool invert_expression)
{ {
if (!match(TokenType::Between)) if (!match(TokenType::Between))
return {}; return {};
@ -792,7 +792,7 @@ Optional<NonnullRefPtr<Expression>> Parser::parse_between_expression(NonnullRefP
return create_ast_node<BetweenExpression>(move(expression), binary_expression.lhs(), binary_expression.rhs(), invert_expression); return create_ast_node<BetweenExpression>(move(expression), binary_expression.lhs(), binary_expression.rhs(), invert_expression);
} }
Optional<NonnullRefPtr<Expression>> Parser::parse_in_expression(NonnullRefPtr<Expression> expression, bool invert_expression) RefPtr<Expression> Parser::parse_in_expression(NonnullRefPtr<Expression> expression, bool invert_expression)
{ {
if (!match(TokenType::In)) if (!match(TokenType::In))
return {}; return {};

28
Userland/Libraries/LibSQL/AST/Parser.h
View file

@ -68,20 +68,20 @@ private:
NonnullRefPtr<Expression> parse_primary_expression(); NonnullRefPtr<Expression> parse_primary_expression();
NonnullRefPtr<Expression> parse_secondary_expression(NonnullRefPtr<Expression> primary); NonnullRefPtr<Expression> parse_secondary_expression(NonnullRefPtr<Expression> primary);
bool match_secondary_expression() const; bool match_secondary_expression() const;
Optional<NonnullRefPtr<Expression>> parse_literal_value_expression(); RefPtr<Expression> parse_literal_value_expression();
Optional<NonnullRefPtr<Expression>> parse_column_name_expression(String with_parsed_identifier = {}, bool with_parsed_period = false); RefPtr<Expression> parse_column_name_expression(String with_parsed_identifier = {}, bool with_parsed_period = false);
Optional<NonnullRefPtr<Expression>> parse_unary_operator_expression(); RefPtr<Expression> parse_unary_operator_expression();
Optional<NonnullRefPtr<Expression>> parse_binary_operator_expression(NonnullRefPtr<Expression> lhs); RefPtr<Expression> parse_binary_operator_expression(NonnullRefPtr<Expression> lhs);
Optional<NonnullRefPtr<Expression>> parse_chained_expression(); RefPtr<Expression> parse_chained_expression();
Optional<NonnullRefPtr<Expression>> parse_cast_expression(); RefPtr<Expression> parse_cast_expression();
Optional<NonnullRefPtr<Expression>> parse_case_expression(); RefPtr<Expression> parse_case_expression();
Optional<NonnullRefPtr<Expression>> parse_exists_expression(bool invert_expression, TokenType opening_token = TokenType::Exists); RefPtr<Expression> parse_exists_expression(bool invert_expression, TokenType opening_token = TokenType::Exists);
Optional<NonnullRefPtr<Expression>> parse_collate_expression(NonnullRefPtr<Expression> expression); RefPtr<Expression> parse_collate_expression(NonnullRefPtr<Expression> expression);
Optional<NonnullRefPtr<Expression>> parse_is_expression(NonnullRefPtr<Expression> expression); RefPtr<Expression> parse_is_expression(NonnullRefPtr<Expression> expression);
Optional<NonnullRefPtr<Expression>> parse_match_expression(NonnullRefPtr<Expression> lhs, bool invert_expression); RefPtr<Expression> parse_match_expression(NonnullRefPtr<Expression> lhs, bool invert_expression);
Optional<NonnullRefPtr<Expression>> parse_null_expression(NonnullRefPtr<Expression> expression, bool invert_expression); RefPtr<Expression> parse_null_expression(NonnullRefPtr<Expression> expression, bool invert_expression);
Optional<NonnullRefPtr<Expression>> parse_between_expression(NonnullRefPtr<Expression> expression, bool invert_expression); RefPtr<Expression> parse_between_expression(NonnullRefPtr<Expression> expression, bool invert_expression);
Optional<NonnullRefPtr<Expression>> parse_in_expression(NonnullRefPtr<Expression> expression, bool invert_expression); RefPtr<Expression> parse_in_expression(NonnullRefPtr<Expression> expression, bool invert_expression);
NonnullRefPtr<ColumnDefinition> parse_column_definition(); NonnullRefPtr<ColumnDefinition> parse_column_definition();
NonnullRefPtr<TypeName> parse_type_name(); NonnullRefPtr<TypeName> parse_type_name();