ast-builder: Add more methods

This commit adds new methods for building pattern nodes, match expressions and more precise call expressions.

gcc/rust/ChangeLog:

	* ast/rust-ast-builder.cc: Add new functions.
	* ast/rust-ast-builder.h: Declare them.

Author: CohenArthur

gcc/rust/ast/rust-ast-builder.cc

@@ -20,6 +20,7 @@
 #include "rust-ast-builder-type.h"
 #include "rust-common.h"
 #include "rust-expr.h"
+#include "rust-path.h"
 #include "rust-token.h"
 #include "rust-make-unique.h"
 
@@ -42,6 +43,33 @@ Builder::call (std::unique_ptr<Expr> &&path,
     new CallExpr (std::move (path), std::move (args), {}, loc));
 }
 
+std::unique_ptr<Expr>
+Builder::call (std::unique_ptr<Path> &&path,
+	       std::vector<std::unique_ptr<Expr>> &&args) const
+{
+  return call (std::unique_ptr<Expr> (
+		 new PathInExpression (std::move (path), {}, loc)),
+	       std::move (args));
+}
+
+std::unique_ptr<Expr>
+Builder::call (std::unique_ptr<Expr> &&path, std::unique_ptr<Expr> &&arg) const
+{
+  auto args = std::vector<std::unique_ptr<Expr>> ();
+  args.emplace_back (std::move (arg));
+
+  return call (std::move (path), std::move (args));
+}
+
+std::unique_ptr<Expr>
+Builder::call (std::unique_ptr<Path> &&path, std::unique_ptr<Expr> &&arg) const
+{
+  auto args = std::vector<std::unique_ptr<Expr>> ();
+  args.emplace_back (std::move (arg));
+
+  return call (std::move (path), std::move (args));
+}
+
 std::unique_ptr<Expr>
 Builder::array (std::vector<std::unique_ptr<Expr>> &&members) const
 {
@@ -56,6 +84,13 @@ Builder::identifier (std::string name) const
   return std::unique_ptr<Expr> (new IdentifierExpr (name, {}, loc));
 }
 
+std::unique_ptr<Pattern>
+Builder::identifier_pattern (std::string name, bool mut) const
+{
+  return std::unique_ptr<Pattern> (
+    new IdentifierPattern (name, loc, false, mut));
+}
+
 std::unique_ptr<Expr>
 Builder::tuple_idx (std::string receiver, int idx) const
 {
@@ -117,6 +152,22 @@ Builder::path_in_expression (std::vector<std::string> &&segments) const
   return PathInExpression (std::move (path_segments), {}, loc);
 }
 
+PathInExpression
+Builder::path_in_expression (LangItem::Kind lang_item) const
+{
+  return PathInExpression (lang_item, {}, loc);
+}
+
+std::unique_ptr<Expr>
+Builder::block (std::unique_ptr<Stmt> &&stmt,
+		std::unique_ptr<Expr> &&tail_expr) const
+{
+  auto stmts = std::vector<std::unique_ptr<Stmt>> ();
+  stmts.emplace_back (std::move (stmt));
+
+  return block (std::move (stmts), std::move (tail_expr));
+}
+
 std::unique_ptr<Expr>
 Builder::block (std::vector<std::unique_ptr<Stmt>> &&stmts,
 		std::unique_ptr<Expr> &&tail_expr) const
@@ -189,6 +240,46 @@ Builder::wildcard () const
   return std::unique_ptr<Pattern> (new WildcardPattern (loc));
 }
 
+std::unique_ptr<Path>
+Builder::lang_item_path (LangItem::Kind kind) const
+{
+  return std::unique_ptr<Path> (new LangItemPath (kind, loc));
+}
+
+std::unique_ptr<Expr>
+Builder::match (std::unique_ptr<Expr> &&scrutinee,
+		std::vector<MatchCase> &&cases)
+{
+  return std::unique_ptr<Expr> (
+    new MatchExpr (std::move (scrutinee), std::move (cases), {}, {}, loc));
+}
+
+MatchArm
+Builder::match_arm (std::unique_ptr<Pattern> &&pattern)
+{
+  auto patterns = std::vector<std::unique_ptr<Pattern>> ();
+  patterns.emplace_back (std::move (pattern));
+
+  return MatchArm (std::move (patterns), loc);
+}
+
+MatchCase
+Builder::match_case (std::unique_ptr<Pattern> &&pattern,
+		     std::unique_ptr<Expr> &&expr)
+{
+  return MatchCase (match_arm (std::move (pattern)), std::move (expr));
+}
+
+std::unique_ptr<Expr>
+Builder::loop (std::vector<std::unique_ptr<Stmt>> &&stmts)
+{
+  auto block = std::unique_ptr<BlockExpr> (
+    new BlockExpr (std::move (stmts), nullptr, {}, {}, LoopLabel::error (), loc,
+		   loc));
+
+  return std::unique_ptr<Expr> (new LoopExpr (std::move (block), loc));
+}
+
 std::unique_ptr<Type>
 Builder::new_type (Type &type)
 {

gcc/rust/ast/rust-ast-builder.h

@@ -20,6 +20,7 @@
 #define AST_BUILDER_H
 
 #include "rust-ast-full.h"
+#include "rust-expr.h"
 
 namespace Rust {
 namespace AST {
@@ -38,6 +39,8 @@ class Builder
 
   /* Create an identifier expression (`variable`) */
   std::unique_ptr<Expr> identifier (std::string name) const;
+  std::unique_ptr<Pattern> identifier_pattern (std::string name,
+					       bool mut = false) const;
 
   /* Create a tuple index expression (`receiver.0`) */
   std::unique_ptr<Expr> tuple_idx (std::string receiver, int idx) const;
@@ -53,6 +56,9 @@ class Builder
   std::unique_ptr<Expr> block (std::vector<std::unique_ptr<Stmt>> &&stmts,
 			       std::unique_ptr<Expr> &&tail_expr
 			       = nullptr) const;
+  std::unique_ptr<Expr> block (std::unique_ptr<Stmt> &&stmt,
+			       std::unique_ptr<Expr> &&tail_expr
+			       = nullptr) const;
 
   /* Create a let binding with an optional type and initializer (`let <name> :
    * <type> = <init>`) */
@@ -66,6 +72,12 @@ class Builder
    */
   std::unique_ptr<Expr> call (std::unique_ptr<Expr> &&path,
 			      std::vector<std::unique_ptr<Expr>> &&args) const;
+  std::unique_ptr<Expr> call (std::unique_ptr<Path> &&path,
+			      std::vector<std::unique_ptr<Expr>> &&args) const;
+  std::unique_ptr<Expr> call (std::unique_ptr<Expr> &&path,
+			      std::unique_ptr<Expr> &&arg) const;
+  std::unique_ptr<Expr> call (std::unique_ptr<Path> &&path,
+			      std::unique_ptr<Expr> &&arg) const;
 
   /**
    * Create an array expression (`[member0, member1, member2]`)
@@ -100,6 +112,11 @@ class Builder
   PathInExpression
   path_in_expression (std::vector<std::string> &&segments) const;
 
+  /**
+   * Create a path in expression from a lang item.
+   */
+  PathInExpression path_in_expression (LangItem::Kind lang_item) const;
+
   /* Create a struct expression for unit structs (`S`) */
   std::unique_ptr<Expr> struct_expr_struct (std::string struct_name) const;
 
@@ -122,6 +139,19 @@ class Builder
   /* Create a wildcard pattern (`_`) */
   std::unique_ptr<Pattern> wildcard () const;
 
+  /* Create a lang item path usable as a general path */
+  std::unique_ptr<Path> lang_item_path (LangItem::Kind) const;
+
+  /* Create match expressions and their components */
+  std::unique_ptr<Expr> match (std::unique_ptr<Expr> &&scrutinee,
+			       std::vector<MatchCase> &&cases);
+  MatchArm match_arm (std::unique_ptr<Pattern> &&pattern);
+  MatchCase match_case (std::unique_ptr<Pattern> &&pattern,
+			std::unique_ptr<Expr> &&expr);
+
+  /* Create a loop expression */
+  std::unique_ptr<Expr> loop (std::vector<std::unique_ptr<Stmt>> &&stmts);
+
   static std::unique_ptr<Type> new_type (Type &type);
 
   static std::unique_ptr<GenericParam>