[gcc/devel/rust/master] ast: Dump where clause and recursively needed nodes

[gcc/devel/rust/master] ast: Dump where clause and recursively needed nodes

[Thomas Schwinge]

https://gcc.gnu.org/g:22977337faf0c1a80af36b00249aed30fa586f2d

commit 22977337faf0c1a80af36b00249aed30fa586f2d
Author: Jakub Dupak <dev@jakubdupak.com>
Date:   Fri Nov 4 23:48:12 2022 +0100

    ast: Dump where clause and recursively needed nodes
    
    This is currently needed for lifetimes to use the existing infrastructure.
    
    Signed-off-by: Jakub Dupak <dev@jakubdupak.com>

Diff:
---
 gcc/rust/ast/rust-ast-dump.cc | 140 +++++++++++++++++++++++++++++++++++++-----
 gcc/rust/ast/rust-ast-dump.h  |   2 +
 gcc/rust/ast/rust-ast.h       |   2 +
 gcc/rust/ast/rust-item.h      |   2 +
 gcc/rust/ast/rust-type.h      |   2 +
 5 files changed, 131 insertions(+), 17 deletions(-)

diff --git a/gcc/rust/ast/rust-ast-dump.cc b/gcc/rust/ast/rust-ast-dump.cc
index 16c4a79dc6e..e5e051a46d8 100644
--- a/gcc/rust/ast/rust-ast-dump.cc
+++ b/gcc/rust/ast/rust-ast-dump.cc
@@ -227,6 +227,28 @@ Dump::visit (StructField &field)
   visit (field.get_field_type ());
 }
 
+// TODO is this unique by type?
+void
+Dump::visit (std::vector<LifetimeParam> &for_lifetimes)
+{
+  // ForLifetimes :
+  //     for GenericParams
+  //
+  // GenericParams :
+  //      < >
+  //   | < (GenericParam ,)* GenericParam ,? >
+  //
+  // GenericParam :
+  //   OuterAttribute* ( LifetimeParam | TypeParam | ConstParam )
+  //
+  // LifetimeParam :
+  //   LIFETIME_OR_LABEL ( : LifetimeBounds )?
+
+  stream << "for <";
+  visit_items_joined_by_separator (for_lifetimes, " + ");
+  stream << "> ";
+}
+
 void
 Dump::visit (Token &tok)
 {
@@ -258,11 +280,35 @@ Dump::visit (IdentifierExpr &ident_expr)
 
 void
 Dump::visit (Lifetime &lifetime)
-{}
+{
+  // Syntax:
+  // Lifetime :
+  // 	LIFETIME_OR_LABEL
+  // 	| 'static
+  // 	| '_
+  stream << lifetime.as_string ();
+}
 
 void
 Dump::visit (LifetimeParam &lifetime_param)
-{}
+{
+  // Syntax:
+  //   LIFETIME_OR_LABEL ( : LifetimeBounds )?
+  // LifetimeBounds :
+  //   ( Lifetime + )* Lifetime?
+
+  // TODO what to do with outer attr? They are not mentioned in the reference.
+
+  auto lifetime = lifetime_param.get_lifetime ();
+  visit (lifetime);
+
+  if (lifetime_param.has_lifetime_bounds ())
+    {
+      stream << ": ";
+      visit_items_joined_by_separator (lifetime_param.get_lifetime_bounds (),
+				       " + ");
+    }
+}
 
 void
 Dump::visit (ConstGenericParam &lifetime_param)
@@ -804,13 +850,52 @@ Dump::visit (TypeParam &param)
     }
 }
 
+void
+Dump::visit (WhereClause &rule)
+{
+  // Syntax:
+  // 	where ( WhereClauseItem , )* WhereClauseItem ?
+  // WhereClauseItem :
+  // 	LifetimeWhereClauseItem
+  //  	| TypeBoundWhereClauseItem
+
+  stream << " where\n";
+  indentation.increment ();
+  visit_items_as_lines (rule.get_items (), ",");
+  indentation.decrement ();
+}
+
 void
 Dump::visit (LifetimeWhereClauseItem &item)
-{}
+{
+  // Syntax:
+  // 	Lifetime : LifetimeBounds
+  // LifetimeBounds :
+  //   ( Lifetime + )* Lifetime?
+
+  visit (item.get_lifetime ());
+  stream << ": ";
+  visit_items_joined_by_separator (item.get_lifetime_bounds (), " + ");
+}
 
 void
 Dump::visit (TypeBoundWhereClauseItem &item)
-{}
+{
+  // Syntax:
+  // 	ForLifetimes? Type : TypeParamBounds?
+  // TypeParamBounds :
+  // 	TypeParamBound ( + TypeParamBound )* +?
+  // TypeParamBound :
+  //    Lifetime | TraitBound
+
+  if (item.has_for_lifetimes ())
+    visit (item.get_for_lifetimes ());
+
+  visit (item.get_type ());
+  stream << ": ";
+
+  visit_items_joined_by_separator (item.get_type_param_bounds (), " + ");
+}
 
 void
 Dump::visit (Method &method)
@@ -896,6 +981,12 @@ Dump::visit (UseDeclaration &use_decl)
 void
 Dump::visit (Function &function)
 {
+  // Syntax:
+  //   FunctionQualifiers fn IDENTIFIER GenericParams?
+  //      ( FunctionParameters? )
+  //      FunctionReturnType? WhereClause?
+  //      ( BlockExpression | ; )
+
   visit (function.get_visibility ());
 
   stream << "fn " << function.get_function_name ();
@@ -913,6 +1004,9 @@ Dump::visit (Function &function)
       stream << " ";
     }
 
+  if (function.has_where_clause ())
+    visit (function.get_where_clause ());
+
   auto &block = function.get_definition ();
   if (!block)
     stream << ';';
@@ -936,8 +1030,7 @@ Dump::visit (TypeAlias &type_alias)
   if (type_alias.has_generics ())
     visit (type_alias.get_generic_params ());
   if (type_alias.has_where_clause ())
-    {
-    } // FIXME: WhereClause
+    visit (type_alias.get_where_clause ());
   stream << " = ";
   visit (type_alias.get_type_aliased ());
   stream << ";\n";
@@ -949,9 +1042,8 @@ Dump::visit (StructStruct &struct_item)
   stream << "struct " << struct_item.get_identifier ();
   if (struct_item.has_generics ())
     visit (struct_item.get_generic_params ());
-
-  // FIXME: where-clause
-
+  if (struct_item.has_where_clause ())
+    visit (struct_item.get_where_clause ());
   if (struct_item.is_unit_struct ())
     stream << ";\n";
   else
@@ -964,8 +1056,8 @@ Dump::visit (TupleStruct &tuple_struct)
   stream << "struct " << tuple_struct.get_identifier ();
   if (tuple_struct.has_generics ())
     visit (tuple_struct.get_generic_params ());
-
-  // FIXME: where-clause
+  if (tuple_struct.has_where_clause ())
+    visit (tuple_struct.get_where_clause ());
 
   stream << '(';
   visit_items_joined_by_separator (tuple_struct.get_fields (), ", ");
@@ -1006,8 +1098,8 @@ Dump::visit (Enum &enum_item)
   stream << "enum " << enum_item.get_identifier ();
   if (enum_item.has_generics ())
     visit (enum_item.get_generic_params ());
-
-  // FIXME: where-clause
+  if (enum_item.has_where_clause ())
+    visit (enum_item.get_where_clause ());
 
   visit_items_as_block (enum_item.get_variants (), ",");
 }
@@ -1018,8 +1110,8 @@ Dump::visit (Union &union_item)
   stream << "union " << union_item.get_identifier ();
   if (union_item.has_generics ())
     visit (union_item.get_generic_params ());
-
-  // FIXME: where-clause
+  if (union_item.has_where_clause ())
+    visit (union_item.get_where_clause ());
 
   visit_items_as_block (union_item.get_variants (), ",");
 }
@@ -1137,7 +1229,9 @@ Dump::visit (InherentImpl &impl)
 
   visit (impl.get_type ());
 
-  // FIXME: Handle where-clause
+  if (impl.has_where_clause ())
+    visit (impl.get_where_clause ());
+
   // FIXME: Handle inner attributes
 
   visit_items_as_block (impl.get_impl_items (), "");
@@ -1451,7 +1545,19 @@ Dump::visit (ExprStmtWithBlock &stmt)
 // rust-type.h
 void
 Dump::visit (TraitBound &bound)
-{}
+{
+  // Syntax:
+  //      ?? ForLifetimes? TypePath
+  //   | ( ?? ForLifetimes? TypePath )
+
+  if (bound.has_opening_question_mark ())
+    stream << "? ";
+
+  if (bound.has_for_lifetimes ())
+    visit (bound.get_for_lifetimes ());
+
+  visit (bound.get_type_path ());
+}
 
 void
 Dump::visit (ImplTraitType &type)
diff --git a/gcc/rust/ast/rust-ast-dump.h b/gcc/rust/ast/rust-ast-dump.h
index 57419b75347..2bd3b31d09a 100644
--- a/gcc/rust/ast/rust-ast-dump.h
+++ b/gcc/rust/ast/rust-ast-dump.h
@@ -135,6 +135,8 @@ private:
   void visit (SimplePathSegment &segment);
   void visit (NamedFunctionParam &param);
   void visit (MacroRule &rule);
+  void visit (WhereClause &rule);
+  void visit (std::vector<LifetimeParam> &for_lifetimes);
 
   // rust-ast.h
   void visit (Token &tok);
diff --git a/gcc/rust/ast/rust-ast.h b/gcc/rust/ast/rust-ast.h
index e0e10dc0d30..fc7af58eed5 100644
--- a/gcc/rust/ast/rust-ast.h
+++ b/gcc/rust/ast/rust-ast.h
@@ -1310,6 +1310,8 @@ public:
   // Returns whether the lifetime param has any lifetime bounds.
   bool has_lifetime_bounds () const { return !lifetime_bounds.empty (); }
 
+  std::vector<Lifetime> &get_lifetime_bounds () { return lifetime_bounds; }
+
   // Returns whether the lifetime param has an outer attribute.
   bool has_outer_attribute () const { return !outer_attr.is_empty (); }
 
diff --git a/gcc/rust/ast/rust-item.h b/gcc/rust/ast/rust-item.h
index b1888659052..09fad819c45 100644
--- a/gcc/rust/ast/rust-item.h
+++ b/gcc/rust/ast/rust-item.h
@@ -236,6 +236,8 @@ public:
   // Returns whether the item has ForLifetimes
   bool has_for_lifetimes () const { return !for_lifetimes.empty (); }
 
+  std::vector<LifetimeParam> &get_for_lifetimes () { return for_lifetimes; }
+
   // Returns whether the item has type param bounds
   bool has_type_param_bounds () const { return !type_param_bounds.empty (); }
 
diff --git a/gcc/rust/ast/rust-type.h b/gcc/rust/ast/rust-type.h
index 7e9e07d0c18..8fc3d31b45b 100644
--- a/gcc/rust/ast/rust-type.h
+++ b/gcc/rust/ast/rust-type.h
@@ -46,6 +46,8 @@ public:
   // Returns whether trait bound has "for" lifetimes
   bool has_for_lifetimes () const { return !for_lifetimes.empty (); }
 
+  std::vector<LifetimeParam> &get_for_lifetimes () { return for_lifetimes; }
+
   TraitBound (TypePath type_path, Location locus, bool in_parens = false,
 	      bool opening_question_mark = false,
 	      std::vector<LifetimeParam> for_lifetimes