gccrs: ast: Implement remaining expr TokenStream visitor

Implement the missing expression functions visitors for TokenStream.

gcc/rust/ChangeLog:

	* ast/rust-ast-tokenstream.cc (TokenStream::visit): Add
	visitors.
	(TokenStream::visit_closure_common): Merge common code for
	closure visitors.
	* ast/rust-ast-tokenstream.h: Add function prototype.
	* ast/rust-expr.h: Add missing move attribute getter.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

diff --git a/gcc/rust/ast/rust-ast-tokenstream.cc b/gcc/rust/ast/rust-ast-tokenstream.cc
index c93c24c3fa83fd3e0a32c4077ddaa47486d9a6a1..8dae3e57e673f3eed82af48cfdd931b7eaa138bd 100644 (file)
--- a/gcc/rust/ast/rust-ast-tokenstream.cc
+++ b/gcc/rust/ast/rust-ast-tokenstream.cc
@@ -1099,16 +1099,57 @@ TokenStream::visit (CallExpr &expr)
 }
 
 void
-TokenStream::visit (MethodCallExpr &)
-{}
+TokenStream::visit (MethodCallExpr &expr)
+{
+  visit (expr.get_receiver_expr ());
+  tokens.push_back (Rust::Token::make (DOT, expr.get_locus ()));
+  visit (expr.get_method_name ());
+  tokens.push_back (Rust::Token::make (LEFT_PAREN, Location ()));
+  visit_items_joined_by_separator (expr.get_params (), COMMA);
+  trailing_comma ();
+  tokens.push_back (Rust::Token::make (RIGHT_PAREN, Location ()));
+}
 
 void
-TokenStream::visit (FieldAccessExpr &)
-{}
+TokenStream::visit (FieldAccessExpr &expr)
+{
+  visit (expr.get_receiver_expr ());
+  tokens.push_back (Rust::Token::make (DOT, expr.get_locus ()));
+  auto field_name = expr.get_field_name ();
+  tokens.push_back (
+    Rust::Token::make_identifier (Location (), std::move (field_name)));
+}
 
 void
-TokenStream::visit (ClosureExprInner &)
-{}
+TokenStream::visit (ClosureParam &param)
+{
+  visit_items_as_lines (param.get_outer_attrs ());
+  visit (param.get_pattern ());
+  if (param.has_type_given ())
+    {
+      tokens.push_back (Rust::Token::make (COLON, param.get_locus ()));
+      visit (param.get_type ());
+    }
+}
+
+void
+TokenStream::visit_closure_common (ClosureExpr &expr)
+{
+  if (expr.get_has_move ())
+    {
+      tokens.push_back (Rust::Token::make (MOVE, expr.get_locus ()));
+    }
+  tokens.push_back (Rust::Token::make (PIPE, Location ()));
+  visit_items_joined_by_separator (expr.get_params (), COMMA);
+  tokens.push_back (Rust::Token::make (PIPE, Location ()));
+}
+
+void
+TokenStream::visit (ClosureExprInner &expr)
+{
+  visit_closure_common (expr);
+  visit (expr.get_definition_expr ());
+}
 
 void
 TokenStream::visit (BlockExpr &expr)
@@ -1124,16 +1165,31 @@ TokenStream::visit (BlockExpr &expr)
 }
 
 void
-TokenStream::visit (ClosureExprInnerTyped &)
-{}
+TokenStream::visit (ClosureExprInnerTyped &expr)
+{
+  visit_closure_common (expr);
+  tokens.push_back (Rust::Token::make (RETURN_TYPE, expr.get_locus ()));
+  visit (expr.get_return_type ());
+  visit (expr.get_definition_block ());
+}
 
 void
-TokenStream::visit (ContinueExpr &)
-{}
+TokenStream::visit (ContinueExpr &expr)
+{
+  tokens.push_back (Rust::Token::make (CONTINUE, expr.get_locus ()));
+  if (expr.has_label ())
+    visit (expr.get_label ());
+}
 
 void
-TokenStream::visit (BreakExpr &)
-{}
+TokenStream::visit (BreakExpr &expr)
+{
+  tokens.push_back (Rust::Token::make (BREAK, expr.get_locus ()));
+  if (expr.has_label ())
+    visit (expr.get_label ());
+  if (expr.has_break_expr ())
+    visit (expr.get_break_expr ());
+}
 
 void
 TokenStream::visit (RangeFromToExpr &expr)
@@ -1262,9 +1318,7 @@ TokenStream::visit (IfExpr &expr)
 void
 TokenStream::visit (IfExprConseqElse &expr)
 {
-  tokens.push_back (Rust::Token::make (IF, expr.get_locus ()));
-  visit (expr.get_condition_expr ());
-  visit (expr.get_if_block ());
+  visit (static_cast<IfExpr &> (expr));
   tokens.push_back (Rust::Token::make (ELSE, expr.get_locus ()));
   visit (expr.get_else_block ());
 }
@@ -1272,45 +1326,113 @@ TokenStream::visit (IfExprConseqElse &expr)
 void
 TokenStream::visit (IfExprConseqIf &expr)
 {
-  tokens.push_back (Rust::Token::make (IF, expr.get_locus ()));
-  visit (expr.get_condition_expr ());
-  visit (expr.get_if_block ());
+  visit (static_cast<IfExpr &> (expr));
   tokens.push_back (Rust::Token::make (ELSE, expr.get_locus ()));
   // The "if" part of the "else if" is printed by the next visitor
   visit (expr.get_conseq_if_expr ());
 }
 
 void
-TokenStream::visit (IfExprConseqIfLet &)
-{}
+TokenStream::visit (IfExprConseqIfLet &expr)
+{
+  visit (static_cast<IfExpr &> (expr));
+  tokens.push_back (Rust::Token::make (ELSE, expr.get_locus ()));
+  visit (expr.get_conseq_if_let_expr ());
+}
 
 void
-TokenStream::visit (IfLetExpr &)
-{}
+TokenStream::visit (IfLetExpr &expr)
+{
+  tokens.push_back (Rust::Token::make (IF, expr.get_locus ()));
+  tokens.push_back (Rust::Token::make (LET, Location ()));
+  for (auto &pattern : expr.get_patterns ())
+    {
+      visit (pattern);
+    }
+  tokens.push_back (Rust::Token::make (EQUAL, Location ()));
+  visit (expr.get_value_expr ());
+  visit (expr.get_if_block ());
+}
 
 void
-TokenStream::visit (IfLetExprConseqElse &)
-{}
+TokenStream::visit (IfLetExprConseqElse &expr)
+{
+  visit (static_cast<IfLetExpr &> (expr));
+  tokens.push_back (Rust::Token::make (ELSE, expr.get_locus ()));
+  visit (expr.get_else_block ());
+}
 
 void
-TokenStream::visit (IfLetExprConseqIf &)
-{}
+TokenStream::visit (IfLetExprConseqIf &expr)
+{
+  visit (static_cast<IfLetExpr &> (expr));
+  tokens.push_back (Rust::Token::make (ELSE, expr.get_locus ()));
+  visit (expr.get_conseq_if_expr ());
+}
 
 void
-TokenStream::visit (IfLetExprConseqIfLet &)
-{}
+TokenStream::visit (IfLetExprConseqIfLet &expr)
+{
+  visit (static_cast<IfLetExpr &> (expr));
+  tokens.push_back (Rust::Token::make (ELSE, expr.get_locus ()));
+  visit (expr.get_conseq_if_let_expr ());
+}
 
 void
-TokenStream::visit (MatchExpr &)
-{}
+TokenStream::visit (MatchArm &arm)
+{
+  visit_items_as_lines (arm.get_outer_attrs ());
+  for (auto &pattern : arm.get_patterns ())
+    {
+      visit (pattern);
+    }
+  if (arm.has_match_arm_guard ())
+    {
+      tokens.push_back (Rust::Token::make (IF, Location ()));
+      visit (arm.get_guard_expr ());
+    }
+}
 
 void
-TokenStream::visit (AwaitExpr &)
-{}
+TokenStream::visit (MatchCase &match_case)
+{
+  visit (match_case.get_arm ());
+  tokens.push_back (Rust::Token::make (MATCH_ARROW, Location ()));
+  visit (match_case.get_expr ());
+  trailing_comma ();
+}
 
 void
-TokenStream::visit (AsyncBlockExpr &)
-{}
+TokenStream::visit (MatchExpr &expr)
+{
+  tokens.push_back (Rust::Token::make (MATCH_TOK, expr.get_locus ()));
+  visit (expr.get_scrutinee_expr ());
+  tokens.push_back (Rust::Token::make (LEFT_CURLY, Location ()));
+  visit_items_as_lines (expr.get_inner_attrs ());
+  for (auto &arm : expr.get_match_cases ())
+    {
+      visit (arm);
+    }
+  tokens.push_back (Rust::Token::make (RIGHT_CURLY, Location ()));
+}
+
+void
+TokenStream::visit (AwaitExpr &expr)
+{
+  visit (expr.get_awaited_expr ());
+  tokens.push_back (Rust::Token::make (DOT, expr.get_locus ()));
+  // TODO: Check status of await keyword (Context dependant ?)
+  tokens.push_back (Rust::Token::make_identifier (Location (), "await"));
+}
+
+void
+TokenStream::visit (AsyncBlockExpr &expr)
+{
+  tokens.push_back (Rust::Token::make (ASYNC, expr.get_locus ()));
+  if (expr.get_has_move ())
+    tokens.push_back (Rust::Token::make (MOVE, Location ()));
+  visit (expr.get_block_expr ());
+}
 
 // rust-item.h
 

diff --git a/gcc/rust/ast/rust-ast-tokenstream.h b/gcc/rust/ast/rust-ast-tokenstream.h
index c8a69829d900cfd9dfc3c9c5f6ce9ff801a1e7ef..bf3e0b2cf6aa3f4a847013d9a3327c8c8f93c2d9 100644 (file)
--- a/gcc/rust/ast/rust-ast-tokenstream.h
+++ b/gcc/rust/ast/rust-ast-tokenstream.h
@@ -94,6 +94,8 @@ private:
   void visit_function_common (std::unique_ptr<Type> &return_type,
                              std::unique_ptr<BlockExpr> &block);
 
+  void visit_closure_common (ClosureExpr &expr);
+
   void visit_loop_common (BaseLoopExpr &expr);
   void visit (LoopLabel &label);
 
@@ -170,6 +172,7 @@ private:
   void visit (CallExpr &expr);
   void visit (MethodCallExpr &expr);
   void visit (FieldAccessExpr &expr);
+  void visit (ClosureParam &param);
   void visit (ClosureExprInner &expr);
   void visit (BlockExpr &expr);
   void visit (ClosureExprInnerTyped &expr);
@@ -195,6 +198,8 @@ private:
   void visit (IfLetExprConseqElse &expr);
   void visit (IfLetExprConseqIf &expr);
   void visit (IfLetExprConseqIfLet &expr);
+  void visit (MatchArm &arm);
+  void visit (MatchCase &arm);
   void visit (MatchExpr &expr);
   void visit (AwaitExpr &expr);
   void visit (AsyncBlockExpr &expr);

diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h
index 1b3a85fea411de7d30c35a628264b69f85108ba1..ac32b98913defda9e9ac6209560500dd5240085d 100644 (file)
--- a/gcc/rust/ast/rust-expr.h
+++ b/gcc/rust/ast/rust-expr.h
@@ -4609,6 +4609,7 @@ public:
 
   std::string as_string () const override;
 
+  bool get_has_move () { return has_move; }
   Location get_locus () const override final { return locus; }
 
   void accept_vis (ASTVisitor &vis) override;