1 /* This file is part of GCC.
2
3 GCC is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 3, or (at your option)
6 any later version.
7
8 GCC is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12
13 You should have received a copy of the GNU General Public License
14 along with GCC; see the file COPYING3. If not see
15 <http://www.gnu.org/licenses/>. */
16
17 #ifndef RUST_PARSE_H
18 #define RUST_PARSE_H
19
20 #include "rust-lex.h"
21 #include "rust-ast-full.h"
22 #include "rust-diagnostics.h"
23
24 namespace Rust {
25 /* HACK: used to resolve the expression-or-statement problem at the end of a
26 * block by allowing either to be returned (technically). Tagged union would
27 * probably take up the same amount of space. */
28 struct ExprOrStmt
29 {
30 std::unique_ptr<AST::Expr> expr;
31 std::unique_ptr<AST::Stmt> stmt;
32
33 /* I was going to resist the urge to make this a real class and make it POD,
34 * but construction in steps is too difficult. So it'll just also have a
35 * constructor. */
36
37 // expression constructor
38 ExprOrStmt (std::unique_ptr<AST::Expr> expr) : expr (std::move (expr)) {}
39
40 // statement constructor
41 ExprOrStmt (std::unique_ptr<AST::Stmt> stmt) : stmt (std::move (stmt)) {}
42
43 // macro constructor
44 ExprOrStmt (std::unique_ptr<AST::MacroInvocation> macro)
45 : expr (std::move (macro))
46 {}
47
48 // Returns whether this object is in an error state.
49 bool is_error () const
50 {
51 return (expr == nullptr && stmt == nullptr)
52 || (expr != nullptr && stmt != nullptr);
53 }
54
55 // Returns an error state object.
56 static ExprOrStmt create_error () { return ExprOrStmt (nullptr, nullptr); }
57
58 ~ExprOrStmt () = default;
59
60 /* no copy constructors/assignment as simple object like this shouldn't
61 * require it */
62
63 // move constructors
64 ExprOrStmt (ExprOrStmt &&other) = default;
65 ExprOrStmt &operator= (ExprOrStmt &&other) = default;
66
67 private:
68 // private constructor only used for creating error state expr or stmt objects
69 ExprOrStmt (AST::Expr *expr, AST::Stmt *stmt) : expr (expr), stmt (stmt) {}
70
71 // make this work: have a disambiguation specifically for known statements
72 // (i.e. ';' and 'let'). then, have a special "parse expr or stmt" function
73 // that returns this type. inside it, it parses an expression, and then
74 // determines whether to return expr or stmt via whether the next token is a
75 // semicolon. should be able to disambiguate inside that function between
76 // stmts with blocks and without blocks.
77 };
78
79 /* Restrictions on parsing used to signal that certain ambiguous grammar
80 * features should be parsed in a certain way. */
81 struct ParseRestrictions
82 {
83 bool can_be_struct_expr = true;
84 /* Whether the expression was entered from a unary expression - prevents stuff
85 * like struct exprs being parsed from a dereference. */
86 bool entered_from_unary = false;
87 bool expr_can_be_null = false;
88 bool expr_can_be_stmt = false;
89 bool consume_semi = true;
90 };
91
92 // Parser implementation for gccrs.
93 // TODO: if updated to C++20, ManagedTokenSource would be useful as a concept
94 template <typename ManagedTokenSource> class Parser
95 {
96 public:
97 /**
98 * Consume a token, reporting an error if it isn't the next token
99 *
100 * @param t ID of the token to consume
101 *
102 * @return true if the token was next, false if it wasn't found
103 */
104 bool skip_token (TokenId t);
105
106 /**
107 * Same as `skip_token` but allows for failure without necessarily reporting
108 * an error
109 *
110 * @param t ID of the token to consume
111 *
112 * @return true if the token was next, false if it wasn't found
113 */
114 bool maybe_skip_token (TokenId t);
115
116 std::unique_ptr<AST::Expr>
117 parse_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
118 ParseRestrictions restrictions = ParseRestrictions ());
119
120 std::unique_ptr<AST::LiteralExpr> parse_literal_expr (AST::AttrVec outer_attrs
121 = AST::AttrVec ());
122
123 std::unique_ptr<AST::BlockExpr>
124 parse_block_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
125 Location pratt_parsed_loc = Linemap::unknown_location ());
126
127 std::unique_ptr<AST::Item> parse_item (bool called_from_statement);
128 std::unique_ptr<AST::Pattern> parse_pattern ();
129
130 /**
131 * Parse a statement
132 *
133 * Statement : ';'
134 * | Item
135 * | LetStatement
136 * | ExpressionStatement
137 * | MacroInvocationSemi
138 */
139 std::unique_ptr<AST::Stmt> parse_stmt (ParseRestrictions restrictions
140 = ParseRestrictions ());
141 std::unique_ptr<AST::Type> parse_type (bool save_errors = true);
142 std::unique_ptr<AST::ExternalItem> parse_external_item ();
143 std::unique_ptr<AST::TraitItem> parse_trait_item ();
144 std::unique_ptr<AST::InherentImplItem> parse_inherent_impl_item ();
145 std::unique_ptr<AST::TraitImplItem> parse_trait_impl_item ();
146 AST::PathInExpression parse_path_in_expression ();
147 std::vector<std::unique_ptr<AST::LifetimeParam> > parse_lifetime_params ();
148 AST::Visibility parse_visibility ();
149 std::unique_ptr<AST::IdentifierPattern> parse_identifier_pattern ();
150 std::unique_ptr<AST::TokenTree> parse_token_tree ();
151 AST::Attribute parse_attribute_body ();
152 AST::AttrVec parse_inner_attributes ();
153 std::unique_ptr<AST::MacroInvocation>
154 parse_macro_invocation (AST::AttrVec outer_attrs);
155
156 private:
157 void skip_after_semicolon ();
158 void skip_after_end ();
159 void skip_after_end_block ();
160 void skip_after_next_block ();
161 void skip_after_end_attribute ();
162
163 const_TokenPtr expect_token (TokenId t);
164 void unexpected_token (const_TokenPtr t);
165 bool skip_generics_right_angle ();
166
167 void parse_statement_seq (bool (Parser::*done) ());
168
169 // AST-related stuff - maybe move or something?
170 AST::Attribute parse_inner_attribute ();
171 AST::AttrVec parse_outer_attributes ();
172 AST::Attribute parse_outer_attribute ();
173 std::unique_ptr<AST::AttrInput> parse_attr_input ();
174 AST::Attribute parse_doc_comment ();
175
176 // Path-related
177 AST::SimplePath parse_simple_path ();
178 AST::SimplePathSegment parse_simple_path_segment ();
179 AST::TypePath parse_type_path ();
180 std::unique_ptr<AST::TypePathSegment> parse_type_path_segment ();
181 AST::PathIdentSegment parse_path_ident_segment ();
182 AST::GenericArg parse_generic_arg ();
183 AST::GenericArgs parse_path_generic_args ();
184 AST::GenericArgsBinding parse_generic_args_binding ();
185 AST::TypePathFunction parse_type_path_function (Location locus);
186 AST::PathExprSegment parse_path_expr_segment ();
187 AST::QualifiedPathInExpression
188 // When given a pratt_parsed_loc, use it as the location of the
189 // first token parsed in the expression (the parsing of that first
190 // token should be skipped).
191 parse_qualified_path_in_expression (Location pratt_parsed_loc
192 = Linemap::unknown_location ());
193 AST::QualifiedPathType
194 parse_qualified_path_type (Location pratt_parsed_loc
195 = Linemap::unknown_location ());
196 AST::QualifiedPathInType parse_qualified_path_in_type ();
197
198 // Token tree or macro related
199 AST::DelimTokenTree parse_delim_token_tree ();
200 std::unique_ptr<AST::MacroRulesDefinition>
201 parse_macro_rules_def (AST::AttrVec outer_attrs);
202 std::unique_ptr<AST::MacroRulesDefinition>
203 parse_decl_macro_def (AST::Visibility vis, AST::AttrVec outer_attrs);
204 std::unique_ptr<AST::MacroInvocation>
205 parse_macro_invocation_semi (AST::AttrVec outer_attrs);
206 AST::MacroRule parse_macro_rule ();
207 AST::MacroMatcher parse_macro_matcher ();
208 std::unique_ptr<AST::MacroMatch> parse_macro_match ();
209 std::unique_ptr<AST::MacroMatchFragment> parse_macro_match_fragment ();
210 std::unique_ptr<AST::MacroMatchRepetition> parse_macro_match_repetition ();
211
212 // Top-level item-related
213 std::unique_ptr<AST::VisItem> parse_vis_item (AST::AttrVec outer_attrs);
214
215 // VisItem subclass-related
216 std::unique_ptr<AST::Module> parse_module (AST::Visibility vis,
217 AST::AttrVec outer_attrs);
218 std::unique_ptr<AST::ExternCrate>
219 parse_extern_crate (AST::Visibility vis, AST::AttrVec outer_attrs);
220 std::unique_ptr<AST::UseDeclaration>
221 parse_use_decl (AST::Visibility vis, AST::AttrVec outer_attrs);
222 std::unique_ptr<AST::UseTree> parse_use_tree ();
223 std::unique_ptr<AST::Function> parse_function (AST::Visibility vis,
224 AST::AttrVec outer_attrs);
225 AST::FunctionQualifiers parse_function_qualifiers ();
226 std::vector<std::unique_ptr<AST::GenericParam> >
227 parse_generic_params_in_angles ();
228 template <typename EndTokenPred>
229 std::vector<std::unique_ptr<AST::GenericParam> >
230 parse_generic_params (EndTokenPred is_end_token);
231 template <typename EndTokenPred>
232 std::unique_ptr<AST::GenericParam>
233 parse_generic_param (EndTokenPred is_end_token);
234
235 template <typename EndTokenPred>
236 std::vector<std::unique_ptr<AST::LifetimeParam> >
237 parse_lifetime_params (EndTokenPred is_end_token);
238 std::vector<AST::LifetimeParam> parse_lifetime_params_objs ();
239 template <typename EndTokenPred>
240 std::vector<AST::LifetimeParam>
241 parse_lifetime_params_objs (EndTokenPred is_end_token);
242 template <typename ParseFunction, typename EndTokenPred>
243 auto parse_non_ptr_sequence (
244 ParseFunction parsing_function, EndTokenPred is_end_token,
245 std::string error_msg = "failed to parse generic param in generic params")
246 -> std::vector<decltype (parsing_function ())>;
247 AST::LifetimeParam parse_lifetime_param ();
248 std::vector<std::unique_ptr<AST::TypeParam> > parse_type_params ();
249 template <typename EndTokenPred>
250 std::vector<std::unique_ptr<AST::TypeParam> >
251 parse_type_params (EndTokenPred is_end_token);
252 std::unique_ptr<AST::TypeParam> parse_type_param ();
253 template <typename EndTokenPred>
254 std::vector<AST::FunctionParam>
255 parse_function_params (EndTokenPred is_end_token);
256 AST::FunctionParam parse_function_param ();
257 std::unique_ptr<AST::Type> parse_function_return_type ();
258 AST::WhereClause parse_where_clause ();
259 std::unique_ptr<AST::WhereClauseItem> parse_where_clause_item ();
260 std::unique_ptr<AST::LifetimeWhereClauseItem>
261 parse_lifetime_where_clause_item ();
262 std::unique_ptr<AST::TypeBoundWhereClauseItem>
263 parse_type_bound_where_clause_item ();
264 std::vector<AST::LifetimeParam> parse_for_lifetimes ();
265 template <typename EndTokenPred>
266 std::vector<std::unique_ptr<AST::TypeParamBound> >
267 parse_type_param_bounds (EndTokenPred is_end_token);
268 std::vector<std::unique_ptr<AST::TypeParamBound> > parse_type_param_bounds ();
269 std::unique_ptr<AST::TypeParamBound> parse_type_param_bound ();
270 std::unique_ptr<AST::TraitBound> parse_trait_bound ();
271 std::vector<AST::Lifetime> parse_lifetime_bounds ();
272 template <typename EndTokenPred>
273 std::vector<AST::Lifetime> parse_lifetime_bounds (EndTokenPred is_end_token);
274 AST::Lifetime parse_lifetime ();
275 std::unique_ptr<AST::TypeAlias> parse_type_alias (AST::Visibility vis,
276 AST::AttrVec outer_attrs);
277 std::unique_ptr<AST::Struct> parse_struct (AST::Visibility vis,
278 AST::AttrVec outer_attrs);
279 std::vector<AST::StructField> parse_struct_fields ();
280 template <typename EndTokenPred>
281 std::vector<AST::StructField> parse_struct_fields (EndTokenPred is_end_token);
282 AST::StructField parse_struct_field ();
283 std::vector<AST::TupleField> parse_tuple_fields ();
284 AST::TupleField parse_tuple_field ();
285 std::unique_ptr<AST::Enum> parse_enum (AST::Visibility vis,
286 AST::AttrVec outer_attrs);
287 std::vector<std::unique_ptr<AST::EnumItem> > parse_enum_items ();
288 template <typename EndTokenPred>
289 std::vector<std::unique_ptr<AST::EnumItem> >
290 parse_enum_items (EndTokenPred is_end_token);
291 std::unique_ptr<AST::EnumItem> parse_enum_item ();
292 std::unique_ptr<AST::Union> parse_union (AST::Visibility vis,
293 AST::AttrVec outer_attrs);
294 std::unique_ptr<AST::ConstantItem>
295 parse_const_item (AST::Visibility vis, AST::AttrVec outer_attrs);
296 std::unique_ptr<AST::StaticItem> parse_static_item (AST::Visibility vis,
297 AST::AttrVec outer_attrs);
298 std::unique_ptr<AST::Trait> parse_trait (AST::Visibility vis,
299 AST::AttrVec outer_attrs);
300 std::unique_ptr<AST::TraitItemType>
301 parse_trait_type (AST::AttrVec outer_attrs);
302 std::unique_ptr<AST::TraitItemConst>
303 parse_trait_const (AST::AttrVec outer_attrs);
304 AST::SelfParam parse_self_param ();
305 std::unique_ptr<AST::Impl> parse_impl (AST::Visibility vis,
306 AST::AttrVec outer_attrs);
307 std::unique_ptr<AST::InherentImplItem>
308 parse_inherent_impl_function_or_method (AST::Visibility vis,
309 AST::AttrVec outer_attrs);
310 std::unique_ptr<AST::TraitImplItem>
311 parse_trait_impl_function_or_method (AST::Visibility vis,
312 AST::AttrVec outer_attrs);
313 std::unique_ptr<AST::ExternBlock>
314 parse_extern_block (AST::Visibility vis, AST::AttrVec outer_attrs);
315 AST::NamedFunctionParam parse_named_function_param (AST::AttrVec outer_attrs
316 = AST::AttrVec ());
317 AST::Method parse_method ();
318
319 // Expression-related (Pratt parsed)
320 std::unique_ptr<AST::Expr>
321 parse_expr (int right_binding_power,
322 AST::AttrVec outer_attrs = AST::AttrVec (),
323 ParseRestrictions restrictions = ParseRestrictions ());
324 std::unique_ptr<AST::Expr>
325 null_denotation (const_TokenPtr t, AST::AttrVec outer_attrs = AST::AttrVec (),
326 ParseRestrictions restrictions = ParseRestrictions ());
327 std::unique_ptr<AST::Expr>
328 left_denotation (const_TokenPtr t, std::unique_ptr<AST::Expr> left,
329 AST::AttrVec outer_attrs = AST::AttrVec (),
330 ParseRestrictions restrictions = ParseRestrictions ());
331 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
332 parse_arithmetic_or_logical_expr (
333 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
334 AST::AttrVec outer_attrs, AST::ArithmeticOrLogicalExpr::ExprType expr_type,
335 ParseRestrictions restrictions = ParseRestrictions ());
336 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
337 parse_binary_plus_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
338 AST::AttrVec outer_attrs,
339 ParseRestrictions restrictions
340 = ParseRestrictions ());
341 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
342 parse_binary_minus_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
343 AST::AttrVec outer_attrs,
344 ParseRestrictions restrictions
345 = ParseRestrictions ());
346 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
347 parse_binary_mult_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
348 AST::AttrVec outer_attrs,
349 ParseRestrictions restrictions
350 = ParseRestrictions ());
351 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
352 parse_binary_div_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
353 AST::AttrVec outer_attrs,
354 ParseRestrictions restrictions = ParseRestrictions ());
355 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
356 parse_binary_mod_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
357 AST::AttrVec outer_attrs,
358 ParseRestrictions restrictions = ParseRestrictions ());
359 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
360 parse_bitwise_and_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
361 AST::AttrVec outer_attrs,
362 ParseRestrictions restrictions
363 = ParseRestrictions ());
364 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
365 parse_bitwise_or_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
366 AST::AttrVec outer_attrs,
367 ParseRestrictions restrictions = ParseRestrictions ());
368 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
369 parse_bitwise_xor_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
370 AST::AttrVec outer_attrs,
371 ParseRestrictions restrictions
372 = ParseRestrictions ());
373 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
374 parse_left_shift_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
375 AST::AttrVec outer_attrs,
376 ParseRestrictions restrictions = ParseRestrictions ());
377 std::unique_ptr<AST::ArithmeticOrLogicalExpr>
378 parse_right_shift_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
379 AST::AttrVec outer_attrs,
380 ParseRestrictions restrictions
381 = ParseRestrictions ());
382 std::unique_ptr<AST::ComparisonExpr>
383 parse_comparison_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
384 AST::AttrVec outer_attrs,
385 AST::ComparisonExpr::ExprType expr_type,
386 ParseRestrictions restrictions = ParseRestrictions ());
387 std::unique_ptr<AST::ComparisonExpr>
388 parse_binary_equal_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
389 AST::AttrVec outer_attrs,
390 ParseRestrictions restrictions
391 = ParseRestrictions ());
392 std::unique_ptr<AST::ComparisonExpr> parse_binary_not_equal_expr (
393 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
394 AST::AttrVec outer_attrs,
395 ParseRestrictions restrictions = ParseRestrictions ());
396 std::unique_ptr<AST::ComparisonExpr> parse_binary_greater_than_expr (
397 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
398 AST::AttrVec outer_attrs,
399 ParseRestrictions restrictions = ParseRestrictions ());
400 std::unique_ptr<AST::ComparisonExpr> parse_binary_less_than_expr (
401 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
402 AST::AttrVec outer_attrs,
403 ParseRestrictions restrictions = ParseRestrictions ());
404 std::unique_ptr<AST::ComparisonExpr> parse_binary_greater_equal_expr (
405 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
406 AST::AttrVec outer_attrs,
407 ParseRestrictions restrictions = ParseRestrictions ());
408 std::unique_ptr<AST::ComparisonExpr> parse_binary_less_equal_expr (
409 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
410 AST::AttrVec outer_attrs,
411 ParseRestrictions restrictions = ParseRestrictions ());
412 std::unique_ptr<AST::LazyBooleanExpr>
413 parse_lazy_or_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
414 AST::AttrVec outer_attrs,
415 ParseRestrictions restrictions = ParseRestrictions ());
416 std::unique_ptr<AST::LazyBooleanExpr>
417 parse_lazy_and_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
418 AST::AttrVec outer_attrs,
419 ParseRestrictions restrictions = ParseRestrictions ());
420 std::unique_ptr<AST::TypeCastExpr>
421 parse_type_cast_expr (const_TokenPtr tok,
422 std::unique_ptr<AST::Expr> expr_to_cast,
423 AST::AttrVec outer_attrs,
424 ParseRestrictions restrictions = ParseRestrictions ());
425 std::unique_ptr<AST::AssignmentExpr>
426 parse_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
427 AST::AttrVec outer_attrs,
428 ParseRestrictions restrictions = ParseRestrictions ());
429 std::unique_ptr<AST::CompoundAssignmentExpr> parse_compound_assignment_expr (
430 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
431 AST::AttrVec outer_attrs, AST::CompoundAssignmentExpr::ExprType expr_type,
432 ParseRestrictions restrictions = ParseRestrictions ());
433 std::unique_ptr<AST::CompoundAssignmentExpr>
434 parse_plus_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
435 AST::AttrVec outer_attrs,
436 ParseRestrictions restrictions = ParseRestrictions ());
437 std::unique_ptr<AST::CompoundAssignmentExpr>
438 parse_minus_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
439 AST::AttrVec outer_attrs,
440 ParseRestrictions restrictions
441 = ParseRestrictions ());
442 std::unique_ptr<AST::CompoundAssignmentExpr>
443 parse_mult_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
444 AST::AttrVec outer_attrs,
445 ParseRestrictions restrictions = ParseRestrictions ());
446 std::unique_ptr<AST::CompoundAssignmentExpr>
447 parse_div_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
448 AST::AttrVec outer_attrs,
449 ParseRestrictions restrictions = ParseRestrictions ());
450 std::unique_ptr<AST::CompoundAssignmentExpr>
451 parse_mod_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
452 AST::AttrVec outer_attrs,
453 ParseRestrictions restrictions = ParseRestrictions ());
454 std::unique_ptr<AST::CompoundAssignmentExpr>
455 parse_and_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
456 AST::AttrVec outer_attrs,
457 ParseRestrictions restrictions = ParseRestrictions ());
458 std::unique_ptr<AST::CompoundAssignmentExpr>
459 parse_or_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
460 AST::AttrVec outer_attrs,
461 ParseRestrictions restrictions = ParseRestrictions ());
462 std::unique_ptr<AST::CompoundAssignmentExpr>
463 parse_xor_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
464 AST::AttrVec outer_attrs,
465 ParseRestrictions restrictions = ParseRestrictions ());
466 std::unique_ptr<AST::CompoundAssignmentExpr> parse_left_shift_assig_expr (
467 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
468 AST::AttrVec outer_attrs,
469 ParseRestrictions restrictions = ParseRestrictions ());
470 std::unique_ptr<AST::CompoundAssignmentExpr> parse_right_shift_assig_expr (
471 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
472 AST::AttrVec outer_attrs,
473 ParseRestrictions restrictions = ParseRestrictions ());
474 std::unique_ptr<AST::AwaitExpr>
475 parse_await_expr (const_TokenPtr tok,
476 std::unique_ptr<AST::Expr> expr_to_await,
477 AST::AttrVec outer_attrs);
478 std::unique_ptr<AST::MethodCallExpr> parse_method_call_expr (
479 const_TokenPtr tok, std::unique_ptr<AST::Expr> receiver_expr,
480 AST::AttrVec outer_attrs,
481 ParseRestrictions restrictions = ParseRestrictions ());
482 std::unique_ptr<AST::CallExpr> parse_function_call_expr (
483 const_TokenPtr tok, std::unique_ptr<AST::Expr> function_expr,
484 AST::AttrVec outer_attrs,
485 ParseRestrictions restrictions = ParseRestrictions ());
486 std::unique_ptr<AST::RangeExpr> parse_led_range_exclusive_expr (
487 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
488 AST::AttrVec outer_attrs,
489 ParseRestrictions restrictions = ParseRestrictions ());
490 std::unique_ptr<AST::RangeExpr>
491 parse_nud_range_exclusive_expr (const_TokenPtr tok, AST::AttrVec outer_attrs);
492 std::unique_ptr<AST::RangeFromToInclExpr> parse_range_inclusive_expr (
493 const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
494 AST::AttrVec outer_attrs,
495 ParseRestrictions restrictions = ParseRestrictions ());
496 std::unique_ptr<AST::RangeToInclExpr>
497 parse_range_to_inclusive_expr (const_TokenPtr tok, AST::AttrVec outer_attrs);
498 std::unique_ptr<AST::TupleIndexExpr> parse_tuple_index_expr (
499 const_TokenPtr tok, std::unique_ptr<AST::Expr> tuple_expr,
500 AST::AttrVec outer_attrs,
501 ParseRestrictions restrictions = ParseRestrictions ());
502 std::unique_ptr<AST::FieldAccessExpr> parse_field_access_expr (
503 const_TokenPtr tok, std::unique_ptr<AST::Expr> struct_expr,
504 AST::AttrVec outer_attrs,
505 ParseRestrictions restrictions = ParseRestrictions ());
506 std::unique_ptr<AST::ArrayIndexExpr>
507 parse_index_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> array_expr,
508 AST::AttrVec outer_attrs,
509 ParseRestrictions restrictions = ParseRestrictions ());
510 std::unique_ptr<AST::MacroInvocation> parse_macro_invocation_partial (
511 AST::PathInExpression path, AST::AttrVec outer_attrs,
512 ParseRestrictions restrictions = ParseRestrictions ());
513 std::unique_ptr<AST::StructExprStruct>
514 parse_struct_expr_struct_partial (AST::PathInExpression path,
515 AST::AttrVec outer_attrs);
516 std::unique_ptr<AST::CallExpr>
517 parse_struct_expr_tuple_partial (AST::PathInExpression path,
518 AST::AttrVec outer_attrs);
519 AST::PathInExpression parse_path_in_expression_pratt (const_TokenPtr tok);
520 std::unique_ptr<AST::ClosureExpr>
521 parse_closure_expr_pratt (const_TokenPtr tok,
522 AST::AttrVec outer_attrs = AST::AttrVec ());
523 std::unique_ptr<AST::TupleIndexExpr> parse_tuple_index_expr_float (
524 const_TokenPtr tok, std::unique_ptr<AST::Expr> tuple_expr,
525 AST::AttrVec outer_attrs,
526 ParseRestrictions restrictions = ParseRestrictions ());
527
528 // Expression-related (non-Pratt parsed)
529 std::unique_ptr<AST::ExprWithBlock>
530 parse_expr_with_block (AST::AttrVec outer_attrs);
531 std::unique_ptr<AST::ExprWithoutBlock>
532 parse_expr_without_block (AST::AttrVec outer_attrs = AST::AttrVec (),
533 ParseRestrictions restrictions
534 = ParseRestrictions ());
535 // When given a pratt_parsed_loc, use it as the location of the
536 // first token parsed in the expression (the parsing of that first
537 // token should be skipped).
538 std::unique_ptr<AST::IfExpr>
539 parse_if_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
540 Location pratt_parsed_loc = Linemap::unknown_location ());
541 std::unique_ptr<AST::IfLetExpr>
542 parse_if_let_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
543 Location pratt_parsed_loc = Linemap::unknown_location ());
544 std::unique_ptr<AST::LoopExpr>
545 parse_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
546 AST::LoopLabel label = AST::LoopLabel::error (),
547 Location pratt_parsed_loc = Linemap::unknown_location ());
548 std::unique_ptr<AST::WhileLoopExpr>
549 parse_while_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
550 AST::LoopLabel label = AST::LoopLabel::error (),
551 Location pratt_parsed_loc
552 = Linemap::unknown_location ());
553 std::unique_ptr<AST::WhileLetLoopExpr>
554 parse_while_let_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
555 AST::LoopLabel label = AST::LoopLabel::error ());
556 std::unique_ptr<AST::ForLoopExpr>
557 parse_for_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
558 AST::LoopLabel label = AST::LoopLabel::error ());
559 std::unique_ptr<AST::MatchExpr>
560 parse_match_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
561 Location pratt_parsed_loc = Linemap::unknown_location ());
562 AST::MatchArm parse_match_arm ();
563 std::vector<std::unique_ptr<AST::Pattern> >
564 parse_match_arm_patterns (TokenId end_token_id);
565 std::unique_ptr<AST::BaseLoopExpr>
566 parse_labelled_loop_expr (AST::AttrVec outer_attrs = AST::AttrVec ());
567 AST::LoopLabel parse_loop_label ();
568 std::unique_ptr<AST::AsyncBlockExpr>
569 parse_async_block_expr (AST::AttrVec outer_attrs = AST::AttrVec ());
570 std::unique_ptr<AST::GroupedExpr> parse_grouped_expr (AST::AttrVec outer_attrs
571 = AST::AttrVec ());
572 std::unique_ptr<AST::ClosureExpr> parse_closure_expr (AST::AttrVec outer_attrs
573 = AST::AttrVec ());
574 AST::ClosureParam parse_closure_param ();
575
576 // When given a pratt_parsed_loc, use it as the location of the
577 // first token parsed in the expression (the parsing of that first
578 // token should be skipped).
579 std::unique_ptr<AST::ReturnExpr>
580 parse_return_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
581 Location pratt_parsed_loc = Linemap::unknown_location ());
582 std::unique_ptr<AST::BreakExpr>
583 parse_break_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
584 Location pratt_parsed_loc = Linemap::unknown_location ());
585 std::unique_ptr<AST::ContinueExpr>
586 parse_continue_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
587 Location pratt_parsed_loc
588 = Linemap::unknown_location ());
589 std::unique_ptr<AST::UnsafeBlockExpr>
590 parse_unsafe_block_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
591 Location pratt_parsed_loc
592 = Linemap::unknown_location ());
593 std::unique_ptr<AST::ArrayExpr>
594 parse_array_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
595 Location pratt_parsed_loc = Linemap::unknown_location ());
596 std::unique_ptr<AST::ExprWithoutBlock>
597 parse_grouped_or_tuple_expr (AST::AttrVec outer_attrs = AST::AttrVec (),
598 Location pratt_parsed_loc
599 = Linemap::unknown_location ());
600 std::unique_ptr<AST::StructExprField> parse_struct_expr_field ();
601 bool will_be_expr_with_block ();
602
603 // Type-related
604 std::unique_ptr<AST::TypeNoBounds> parse_type_no_bounds ();
605 std::unique_ptr<AST::TypeNoBounds> parse_slice_or_array_type ();
606 std::unique_ptr<AST::RawPointerType> parse_raw_pointer_type ();
607 std::unique_ptr<AST::ReferenceType>
608 parse_reference_type_inner (Location locus);
609 std::unique_ptr<AST::ReferenceType> parse_reference_type ();
610 std::unique_ptr<AST::BareFunctionType>
611 parse_bare_function_type (std::vector<AST::LifetimeParam> for_lifetimes);
612 std::unique_ptr<AST::Type> parse_paren_prefixed_type ();
613 std::unique_ptr<AST::TypeNoBounds> parse_paren_prefixed_type_no_bounds ();
614 std::unique_ptr<AST::Type> parse_for_prefixed_type ();
615 AST::MaybeNamedParam parse_maybe_named_param (AST::AttrVec outer_attrs);
616
617 // Statement-related
618
619 /**
620 *Parse a let-statement
621 * LetStatement :
622 * OuterAttribute*
623 * 'let' PatternNoTopAlt ( ':' Type )? ('=' Expression )? ';'
624 *
625 * @param allow_no_semi Allow parsing a let-statement without expecting a
626 * semicolon to follow it
627 */
628 std::unique_ptr<AST::LetStmt> parse_let_stmt (AST::AttrVec outer_attrs,
629 ParseRestrictions restrictions
630 = ParseRestrictions ());
631 std::unique_ptr<AST::ExprStmt> parse_expr_stmt (AST::AttrVec outer_attrs,
632 ParseRestrictions restrictions
633 = ParseRestrictions ());
634 std::unique_ptr<AST::ExprStmtWithBlock>
635 parse_expr_stmt_with_block (AST::AttrVec outer_attrs);
636 std::unique_ptr<AST::ExprStmtWithoutBlock>
637 parse_expr_stmt_without_block (AST::AttrVec outer_attrs,
638 ParseRestrictions restrictions
639 = ParseRestrictions ());
640 ExprOrStmt parse_stmt_or_expr_without_block ();
641 ExprOrStmt parse_stmt_or_expr_with_block (AST::AttrVec outer_attrs);
642 ExprOrStmt parse_macro_invocation_maybe_semi (AST::AttrVec outer_attrs);
643 ExprOrStmt parse_path_based_stmt_or_expr (AST::AttrVec outer_attrs);
644
645 // Pattern-related
646 std::unique_ptr<AST::Pattern> parse_literal_or_range_pattern ();
647 std::unique_ptr<AST::RangePatternBound> parse_range_pattern_bound ();
648 std::unique_ptr<AST::ReferencePattern> parse_reference_pattern ();
649 std::unique_ptr<AST::Pattern> parse_grouped_or_tuple_pattern ();
650 std::unique_ptr<AST::SlicePattern> parse_slice_pattern ();
651 std::unique_ptr<AST::Pattern> parse_ident_leading_pattern ();
652 std::unique_ptr<AST::TupleStructItems> parse_tuple_struct_items ();
653 AST::StructPatternElements parse_struct_pattern_elems ();
654 std::unique_ptr<AST::StructPatternField> parse_struct_pattern_field ();
655 std::unique_ptr<AST::StructPatternField>
656 parse_struct_pattern_field_partial (AST::AttrVec outer_attrs);
657
658 int left_binding_power (const_TokenPtr token);
659
660 bool done_end ();
661 bool done_end_or_else ();
662 bool done_end_of_file ();
663
664 void add_error (Error error) { error_table.push_back (std::move (error)); }
665
666 public:
667 // Construct parser with specified "managed" token source.
668 Parser (ManagedTokenSource &tokenSource) : lexer (tokenSource) {}
669
670 // Parse items without parsing an entire crate. This function is the main
671 // parsing loop of AST::Crate::parse_crate().
672 std::vector<std::unique_ptr<AST::Item> > parse_items ();
673
674 // Main entry point for parser.
675 std::unique_ptr<AST::Crate> parse_crate ();
676
677 void debug_dump_ast_output (AST::Crate &crate, std::ostream &out);
678
679 // Returns whether any parsing errors have occurred.
680 bool has_errors () const { return !error_table.empty (); }
681 // Remove all parsing errors from the table
682 void clear_errors () { error_table.clear (); }
683
684 // Get a reference to the list of errors encountered
685 std::vector<Error> &get_errors () { return error_table; }
686
687 const ManagedTokenSource &get_token_source () const { return lexer; }
688
689 const_TokenPtr peek_current_token () { return lexer.peek_token (0); }
690
691 private:
692 // The token source (usually lexer) associated with the parser.
693 ManagedTokenSource &lexer;
694 // The error list.
695 std::vector<Error> error_table;
696 // The names of inline modules while parsing.
697 std::vector<std::string> inline_module_stack;
698
699 class InlineModuleStackScope
700 {
701 private:
702 Parser &parser;
703
704 public:
705 InlineModuleStackScope (Parser &parser, std::string name) : parser (parser)
706 {
707 parser.inline_module_stack.emplace_back (std::move (name));
708 }
709 ~InlineModuleStackScope () { parser.inline_module_stack.pop_back (); }
710 };
711 };
712
713 std::string
714 extract_module_path (const AST::AttrVec &inner_attrs,
715 const AST::AttrVec &outer_attrs, const std::string &name);
716
717 /**
718 * Check if a MacroMatch is allowed to follow the last parsed MacroMatch.
719 *
720 * @param last_match Last matcher parsed before the current match
721 * @param match Current matcher to check
722 *
723 * @return true if the follow-up is valid, false otherwise
724 */
725 bool
726 is_match_compatible (const AST::MacroMatch &last_match,
727 const AST::MacroMatch ¤t_match);
728 } // namespace Rust
729
730 // as now template, include implementations of all methods
731 #include "rust-parse-impl.h"
732
733 #endif // RUST_PARSE_H