From: The Other <simplytheother@gmail.com>
To: Mark Wielaard <mark@klomp.org>
Cc: gcc-rust@gcc.gnu.org
Subject: Re: [PATCH] Pass pratt parsed token to expr parser functions to fix expr locus
Date: Thu, 29 Jul 2021 09:25:41 +0800 [thread overview]
Message-ID: <01C0429E-15F9-45A7-B800-400EEBDF13CD@gmail.com> (raw)
In-Reply-To: <20210728221342.77649-1-mark@klomp.org>
I think the core idea of this patch (fixing locations) is very important and useful.
But isn’t it overkill to pass the token in instead of just the location? You can avoid a fairly expensive shared_ptr copy by doing so.
> On 29 Jul 2021, at 6:13 am, Mark Wielaard <mark@klomp.org> wrote:
>
> The pratt parser skips the first token of an expression before
> invoking the actual expression parsing function. This makes getting
> the correct starting location of a pratt parsed expression hard. The
> "correction" of the location by subtracting an integer is often wrong
> (since there may be arbitrary whitespace or comments between
> tokens). Fix this by passing the token to the expression parsing
> functions (instead of just providing a pratt_parse boolean). Use this
> token to set the start of the expression.
>
> Before gccrs would generate the following error message:
>
> return.rs:3:22: error: cannot ‘break’ outside of a loop
> 3 | let x = 5 - break return (16 + 2);
> | ^~~~~~~~~~~~~~~~~
>
> Now we get:
>
> return.rs:3:17: error: cannot ‘break’ outside of a loop
> 3 | let x = 5 - break return (16 + 2);
> | ^
> ---
> gcc/rust/parse/rust-parse-impl.h | 180 +++++++++++++------------------
> gcc/rust/parse/rust-parse.h | 58 +++++-----
> 2 files changed, 103 insertions(+), 135 deletions(-)
>
> diff --git a/gcc/rust/parse/rust-parse-impl.h b/gcc/rust/parse/rust-parse-impl.h
> index 340fea70201..6241a972ff7 100644
> --- a/gcc/rust/parse/rust-parse-impl.h
> +++ b/gcc/rust/parse/rust-parse-impl.h
> @@ -6580,7 +6580,7 @@ Parser<ManagedTokenSource>::parse_path_expr_segment ()
> template <typename ManagedTokenSource>
> AST::QualifiedPathInExpression
> Parser<ManagedTokenSource>::parse_qualified_path_in_expression (
> - bool pratt_parse)
> + const_TokenPtr pratt_parsed_token)
> {
> /* Note: the Rust grammar is defined in such a way that it is impossible to
> * determine whether a prospective qualified path is a
> @@ -6595,7 +6595,7 @@ Parser<ManagedTokenSource>::parse_qualified_path_in_expression (
>
> // parse the qualified path type (required)
> AST::QualifiedPathType qual_path_type
> - = parse_qualified_path_type (pratt_parse);
> + = parse_qualified_path_type (pratt_parsed_token);
> if (qual_path_type.is_error ())
> {
> // TODO: should this create a parse error?
> @@ -6661,12 +6661,13 @@ Parser<ManagedTokenSource>::parse_qualified_path_in_expression (
> // Parses the type syntactical construction at the start of a qualified path.
> template <typename ManagedTokenSource>
> AST::QualifiedPathType
> -Parser<ManagedTokenSource>::parse_qualified_path_type (bool pratt_parse)
> +Parser<ManagedTokenSource>::parse_qualified_path_type (
> + const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> + Location locus;
> /* TODO: should this actually be error? is there anywhere where this could be
> * valid? */
> - if (!pratt_parse)
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> if (!skip_token (LEFT_ANGLE))
> @@ -6676,10 +6677,7 @@ Parser<ManagedTokenSource>::parse_qualified_path_type (bool pratt_parse)
> }
> }
> else
> - {
> - // move back by 1 if pratt parsing due to skipping '<'
> - locus = lexer.peek_token ()->get_locus () - 1;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // parse type (required)
> std::unique_ptr<AST::Type> type = parse_type ();
> @@ -7305,10 +7303,10 @@ Parser<ManagedTokenSource>::parse_expr_without_block (AST::AttrVec outer_attrs)
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::BlockExpr>
> Parser<ManagedTokenSource>::parse_block_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> + const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> if (!skip_token (LEFT_CURLY))
> @@ -7318,9 +7316,7 @@ Parser<ManagedTokenSource>::parse_block_expr (AST::AttrVec outer_attrs,
> }
> }
> else
> - {
> - locus = lexer.peek_token ()->get_locus () - 1;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> AST::AttrVec inner_attrs = parse_inner_attributes ();
>
> @@ -7611,22 +7607,17 @@ Parser<ManagedTokenSource>::parse_literal_expr (AST::AttrVec outer_attrs)
> // Parses a return expression (including any expression to return).
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::ReturnExpr>
> -Parser<ManagedTokenSource>::parse_return_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> +Parser<ManagedTokenSource>::parse_return_expr (
> + AST::AttrVec outer_attrs, const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> -
> skip_token (RETURN_TOK);
> }
> else
> - {
> - // minus 7 chars for 6 in return and a space
> - // or just TODO: pass in location data
> - locus = lexer.peek_token ()->get_locus () - 7;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // parse expression to return, if it exists
> ParseRestrictions restrictions;
> @@ -7644,21 +7635,16 @@ Parser<ManagedTokenSource>::parse_return_expr (AST::AttrVec outer_attrs,
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::BreakExpr>
> Parser<ManagedTokenSource>::parse_break_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> + const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> -
> skip_token (BREAK);
> }
> else
> - {
> - // minus 6 chars for 5 in return and a space
> - // or just TODO: pass in location data
> - locus = lexer.peek_token ()->get_locus () - 6;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // parse label (lifetime) if it exists - create dummy first
> AST::Lifetime label = AST::Lifetime::error ();
> @@ -7681,22 +7667,17 @@ Parser<ManagedTokenSource>::parse_break_expr (AST::AttrVec outer_attrs,
> // Parses a continue expression (including any label to continue from).
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::ContinueExpr>
> -Parser<ManagedTokenSource>::parse_continue_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> +Parser<ManagedTokenSource>::parse_continue_expr (
> + AST::AttrVec outer_attrs, const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> -
> skip_token (CONTINUE);
> }
> else
> - {
> - // minus 9 chars for 8 in return and a space
> - // or just TODO: pass in location data
> - locus = lexer.peek_token ()->get_locus () - 9;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // parse label (lifetime) if it exists - create dummy first
> AST::Lifetime label = AST::Lifetime::error ();
> @@ -7740,11 +7721,11 @@ Parser<ManagedTokenSource>::parse_loop_label ()
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::IfExpr>
> Parser<ManagedTokenSource>::parse_if_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> + const_TokenPtr pratt_parsed_token)
> {
> // TODO: make having outer attributes an error?
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> if (!skip_token (IF))
> @@ -7754,9 +7735,7 @@ Parser<ManagedTokenSource>::parse_if_expr (AST::AttrVec outer_attrs,
> }
> }
> else
> - {
> - locus = lexer.peek_token ()->get_locus () - 1;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // detect accidental if let
> if (lexer.peek_token ()->get_id () == LET)
> @@ -7901,12 +7880,12 @@ Parser<ManagedTokenSource>::parse_if_expr (AST::AttrVec outer_attrs,
> * expressions don't support them. */
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::IfLetExpr>
> -Parser<ManagedTokenSource>::parse_if_let_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> +Parser<ManagedTokenSource>::parse_if_let_expr (
> + AST::AttrVec outer_attrs, const_TokenPtr pratt_parsed_token)
> {
> // TODO: make having outer attributes an error?
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> if (!skip_token (IF))
> @@ -7916,9 +7895,7 @@ Parser<ManagedTokenSource>::parse_if_let_expr (AST::AttrVec outer_attrs,
> }
> }
> else
> - {
> - locus = lexer.peek_token ()->get_locus () - 1;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // detect accidental if expr parsed as if let expr
> if (lexer.peek_token ()->get_id () != LET)
> @@ -8094,10 +8071,10 @@ template <typename ManagedTokenSource>
> std::unique_ptr<AST::LoopExpr>
> Parser<ManagedTokenSource>::parse_loop_expr (AST::AttrVec outer_attrs,
> AST::LoopLabel label,
> - bool pratt_parse)
> + const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> if (label.is_error ())
> locus = lexer.peek_token ()->get_locus ();
> @@ -8113,7 +8090,7 @@ Parser<ManagedTokenSource>::parse_loop_expr (AST::AttrVec outer_attrs,
> else
> {
> if (label.is_error ())
> - locus = lexer.peek_token ()->get_locus () - 1;
> + locus = pratt_parsed_token->get_locus ();
> else
> locus = label.get_locus ();
> }
> @@ -8138,12 +8115,12 @@ Parser<ManagedTokenSource>::parse_loop_expr (AST::AttrVec outer_attrs,
> * via parse_labelled_loop_expr, which would call this. */
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::WhileLoopExpr>
> -Parser<ManagedTokenSource>::parse_while_loop_expr (AST::AttrVec outer_attrs,
> - AST::LoopLabel label,
> - bool pratt_parse)
> +Parser<ManagedTokenSource>::parse_while_loop_expr (
> + AST::AttrVec outer_attrs, AST::LoopLabel label,
> + const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> if (label.is_error ())
> locus = lexer.peek_token ()->get_locus ();
> @@ -8159,7 +8136,7 @@ Parser<ManagedTokenSource>::parse_while_loop_expr (AST::AttrVec outer_attrs,
> else
> {
> if (label.is_error ())
> - locus = lexer.peek_token ()->get_locus () - 1;
> + locus = pratt_parsed_token->get_locus ();
> else
> locus = label.get_locus ();
> }
> @@ -8417,21 +8394,16 @@ Parser<ManagedTokenSource>::parse_labelled_loop_expr (AST::AttrVec outer_attrs)
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::MatchExpr>
> Parser<ManagedTokenSource>::parse_match_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> + const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> -
> skip_token (MATCH_TOK);
> }
> else
> - {
> - // TODO: probably just pass in location data as param
> - // get current pos then move back 6 - 5 for match, 1 for space
> - locus = lexer.peek_token ()->get_locus () - 6;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> /* parse scrutinee expression, which is required (and HACK to prevent struct
> * expr) */
> @@ -8704,17 +8676,17 @@ Parser<ManagedTokenSource>::parse_async_block_expr (AST::AttrVec outer_attrs)
> // Parses an unsafe block expression.
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::UnsafeBlockExpr>
> -Parser<ManagedTokenSource>::parse_unsafe_block_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> +Parser<ManagedTokenSource>::parse_unsafe_block_expr (
> + AST::AttrVec outer_attrs, const_TokenPtr pratt_parsed_token)
> {
> Location locus;
> - if (!pratt_parse)
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> skip_token (UNSAFE);
> }
> else
> - locus = lexer.peek_token ()->get_locus () - 1;
> + locus = pratt_parsed_token->get_locus ();
>
> // parse block expression (required)
> std::unique_ptr<AST::BlockExpr> block_expr = parse_block_expr ();
> @@ -8738,19 +8710,16 @@ Parser<ManagedTokenSource>::parse_unsafe_block_expr (AST::AttrVec outer_attrs,
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::ArrayExpr>
> Parser<ManagedTokenSource>::parse_array_expr (AST::AttrVec outer_attrs,
> - bool pratt_parse)
> + const_TokenPtr pratt_parsed_token)
> {
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> -
> skip_token (LEFT_SQUARE);
> }
> else
> - {
> - locus = lexer.peek_token ()->get_locus () - 1;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // parse optional inner attributes
> AST::AttrVec inner_attrs = parse_inner_attributes ();
> @@ -8927,20 +8896,17 @@ Parser<ManagedTokenSource>::parse_closure_param ()
> template <typename ManagedTokenSource>
> std::unique_ptr<AST::ExprWithoutBlock>
> Parser<ManagedTokenSource>::parse_grouped_or_tuple_expr (
> - AST::AttrVec outer_attrs, bool pratt_parse)
> + AST::AttrVec outer_attrs, const_TokenPtr pratt_parsed_token)
> {
> // adjustment to allow Pratt parsing to reuse function without copy-paste
> - Location locus = Linemap::unknown_location ();
> - if (!pratt_parse)
> + Location locus;
> + if (pratt_parsed_token == nullptr)
> {
> locus = lexer.peek_token ()->get_locus ();
> -
> skip_token (LEFT_PAREN);
> }
> else
> - {
> - locus = lexer.peek_token ()->get_locus () - 1;
> - }
> + locus = pratt_parsed_token->get_locus ();
>
> // parse optional inner attributes
> AST::AttrVec inner_attrs = parse_inner_attributes ();
> @@ -12535,7 +12501,7 @@ Parser<ManagedTokenSource>::null_denotation (const_TokenPtr tok,
> // qualified path
> // HACK: add outer attrs to path
> AST::QualifiedPathInExpression path
> - = parse_qualified_path_in_expression (true);
> + = parse_qualified_path_in_expression (tok);
> path.set_outer_attrs (std::move (outer_attrs));
> return std::unique_ptr<AST::QualifiedPathInExpression> (
> new AST::QualifiedPathInExpression (std::move (path)));
> @@ -12578,7 +12544,7 @@ Parser<ManagedTokenSource>::null_denotation (const_TokenPtr tok,
> new AST::LiteralExpr ("false", AST::Literal::BOOL,
> tok->get_type_hint (), {}, tok->get_locus ()));
> case LEFT_PAREN:
> - return parse_grouped_or_tuple_expr (std::move (outer_attrs), true);
> + return parse_grouped_or_tuple_expr (std::move (outer_attrs), tok);
>
> /*case PLUS: { // unary plus operator
> // invoke parse_expr recursively with appropriate priority, etc. for
> @@ -12810,41 +12776,41 @@ Parser<ManagedTokenSource>::null_denotation (const_TokenPtr tok,
> return parse_range_to_inclusive_expr (tok, std::move (outer_attrs));
> case RETURN_TOK:
> // FIXME: is this really a null denotation expression?
> - return parse_return_expr (std::move (outer_attrs), true);
> + return parse_return_expr (std::move (outer_attrs), tok);
> case BREAK:
> // FIXME: is this really a null denotation expression?
> - return parse_break_expr (std::move (outer_attrs), true);
> + return parse_break_expr (std::move (outer_attrs), tok);
> case CONTINUE:
> - return parse_continue_expr (std::move (outer_attrs), true);
> + return parse_continue_expr (std::move (outer_attrs), tok);
> case LEFT_CURLY:
> // ok - this is an expression with block for once.
> - return parse_block_expr (std::move (outer_attrs), true);
> + return parse_block_expr (std::move (outer_attrs), tok);
> case IF:
> // if or if let, so more lookahead to find out
> if (lexer.peek_token (1)->get_id () == LET)
> {
> // if let expr
> - return parse_if_let_expr (std::move (outer_attrs), true);
> + return parse_if_let_expr (std::move (outer_attrs), tok);
> }
> else
> {
> // if expr
> - return parse_if_expr (std::move (outer_attrs), true);
> + return parse_if_expr (std::move (outer_attrs), tok);
> }
> case LOOP:
> return parse_loop_expr (std::move (outer_attrs), AST::LoopLabel::error (),
> - true);
> + tok);
> case WHILE:
> return parse_while_loop_expr (std::move (outer_attrs),
> - AST::LoopLabel::error (), true);
> + AST::LoopLabel::error (), tok);
> case MATCH_TOK:
> // also an expression with block
> - return parse_match_expr (std::move (outer_attrs), true);
> + return parse_match_expr (std::move (outer_attrs), tok);
> case LEFT_SQUARE:
> // array definition expr (not indexing)
> - return parse_array_expr (std::move (outer_attrs), true);
> + return parse_array_expr (std::move (outer_attrs), tok);
> case UNSAFE:
> - return parse_unsafe_block_expr (std::move (outer_attrs), true);
> + return parse_unsafe_block_expr (std::move (outer_attrs), tok);
> default:
> if (!restrictions.expr_can_be_null)
> add_error (Error (tok->get_locus (),
> diff --git a/gcc/rust/parse/rust-parse.h b/gcc/rust/parse/rust-parse.h
> index 1c7bd781b3f..78608839265 100644
> --- a/gcc/rust/parse/rust-parse.h
> +++ b/gcc/rust/parse/rust-parse.h
> @@ -121,8 +121,10 @@ private:
> AST::PathInExpression parse_path_in_expression ();
> AST::PathExprSegment parse_path_expr_segment ();
> AST::QualifiedPathInExpression
> - parse_qualified_path_in_expression (bool pratt_parse = false);
> - AST::QualifiedPathType parse_qualified_path_type (bool pratt_parse = false);
> + parse_qualified_path_in_expression (const_TokenPtr pratt_parsed_token
> + = nullptr);
> + AST::QualifiedPathType
> + parse_qualified_path_type (const_TokenPtr pratt_parsed_token = nullptr);
> AST::QualifiedPathInType parse_qualified_path_in_type ();
>
> // Token tree or macro related
> @@ -470,32 +472,32 @@ private:
> parse_expr_with_block (AST::AttrVec outer_attrs);
> std::unique_ptr<AST::ExprWithoutBlock>
> parse_expr_without_block (AST::AttrVec outer_attrs = AST::AttrVec ());
> - std::unique_ptr<AST::BlockExpr> parse_block_expr (AST::AttrVec outer_attrs
> - = AST::AttrVec (),
> - bool pratt_parse = false);
> - std::unique_ptr<AST::IfExpr> parse_if_expr (AST::AttrVec outer_attrs
> - = AST::AttrVec (),
> - bool pratt_parse = false);
> - std::unique_ptr<AST::IfLetExpr> parse_if_let_expr (AST::AttrVec outer_attrs
> - = AST::AttrVec (),
> - bool pratt_parse = false);
> + std::unique_ptr<AST::BlockExpr>
> + parse_block_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> + const_TokenPtr pratt_parsed_token = nullptr);
> + std::unique_ptr<AST::IfExpr>
> + parse_if_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> + const_TokenPtr pratt_parsed_token = nullptr);
> + std::unique_ptr<AST::IfLetExpr>
> + parse_if_let_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> + const_TokenPtr pratt_parsed_token = nullptr);
> std::unique_ptr<AST::LoopExpr>
> parse_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> AST::LoopLabel label = AST::LoopLabel::error (),
> - bool pratt_parse = false);
> + const_TokenPtr pratt_parsed_token = nullptr);
> std::unique_ptr<AST::WhileLoopExpr>
> parse_while_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> AST::LoopLabel label = AST::LoopLabel::error (),
> - bool pratt_parse = false);
> + const_TokenPtr pratt_parsed_token = nullptr);
> std::unique_ptr<AST::WhileLetLoopExpr>
> parse_while_let_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> AST::LoopLabel label = AST::LoopLabel::error ());
> std::unique_ptr<AST::ForLoopExpr>
> parse_for_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> AST::LoopLabel label = AST::LoopLabel::error ());
> - std::unique_ptr<AST::MatchExpr> parse_match_expr (AST::AttrVec outer_attrs
> - = AST::AttrVec (),
> - bool pratt_parse = false);
> + std::unique_ptr<AST::MatchExpr>
> + parse_match_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> + const_TokenPtr pratt_parsed_token = nullptr);
> AST::MatchArm parse_match_arm ();
> std::vector<std::unique_ptr<AST::Pattern> >
> parse_match_arm_patterns (TokenId end_token_id);
> @@ -511,24 +513,24 @@ private:
> AST::ClosureParam parse_closure_param ();
> std::unique_ptr<AST::LiteralExpr> parse_literal_expr (AST::AttrVec outer_attrs
> = AST::AttrVec ());
> - std::unique_ptr<AST::ReturnExpr> parse_return_expr (AST::AttrVec outer_attrs
> - = AST::AttrVec (),
> - bool pratt_parse = false);
> - std::unique_ptr<AST::BreakExpr> parse_break_expr (AST::AttrVec outer_attrs
> - = AST::AttrVec (),
> - bool pratt_parse = false);
> + std::unique_ptr<AST::ReturnExpr>
> + parse_return_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> + const_TokenPtr pratt_parsed_token = nullptr);
> + std::unique_ptr<AST::BreakExpr>
> + parse_break_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> + const_TokenPtr pratt_parsed_token = nullptr);
> std::unique_ptr<AST::ContinueExpr>
> parse_continue_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> - bool pratt_parse = false);
> + const_TokenPtr pratt_parsed_token = nullptr);
> std::unique_ptr<AST::UnsafeBlockExpr>
> parse_unsafe_block_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> - bool pratt_parse = false);
> - std::unique_ptr<AST::ArrayExpr> parse_array_expr (AST::AttrVec outer_attrs
> - = AST::AttrVec (),
> - bool pratt_parse = false);
> + const_TokenPtr pratt_parsed_token = nullptr);
> + std::unique_ptr<AST::ArrayExpr>
> + parse_array_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> + const_TokenPtr pratt_parsed_token = nullptr);
> std::unique_ptr<AST::ExprWithoutBlock>
> parse_grouped_or_tuple_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
> - bool pratt_parse = false);
> + const_TokenPtr pratt_parsed_token = nullptr);
> std::unique_ptr<AST::StructExprField> parse_struct_expr_field ();
> bool will_be_expr_with_block ();
>
> --
> 2.32.0
>
> --
> Gcc-rust mailing list
> Gcc-rust@gcc.gnu.org
> https://gcc.gnu.org/mailman/listinfo/gcc-rust
next prev parent reply other threads:[~2021-07-29 1:25 UTC|newest]
Thread overview: 10+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-07-28 22:13 Mark Wielaard
2021-07-29 1:25 ` The Other [this message]
2021-07-29 10:55 ` Mark Wielaard
2021-07-29 15:18 ` Thomas Schwinge
2021-07-30 1:03 ` Mark Wielaard
2021-08-05 19:37 ` Mark Wielaard
2021-08-06 15:23 ` Philip Herron
2021-08-07 1:01 ` Mark Wielaard
2021-08-08 11:53 ` Philip Herron
2021-08-09 14:24 ` Mark Wielaard
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=01C0429E-15F9-45A7-B800-400EEBDF13CD@gmail.com \
--to=simplytheother@gmail.com \
--cc=gcc-rust@gcc.gnu.org \
--cc=mark@klomp.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).