gccrs: ast-builder: Add new methods for creating operator expressions

gcc/rust/ChangeLog:

	* ast/rust-ast-builder.cc (Builder::literal_bool): New method.
	(Builder::comparison_expr): Likewise.
	(Builder::boolean_operation): Likewise.
	* ast/rust-ast-builder.h: Declare them.

diff --git a/gcc/rust/ast/rust-ast-builder.cc b/gcc/rust/ast/rust-ast-builder.cc
index f59ff19d621578771dd406b87186d2dcf5984487..82e6a5abe24b5b1fcca27c72679df1a59a0a858c 100644 (file)
--- a/gcc/rust/ast/rust-ast-builder.cc
+++ b/gcc/rust/ast/rust-ast-builder.cc
@@ -21,9 +21,11 @@
 #include "rust-ast.h"
 #include "rust-common.h"
 #include "rust-expr.h"
+#include "rust-keyword-values.h"
 #include "rust-path.h"
 #include "rust-item.h"
 #include "rust-path.h"
+#include "rust-pattern.h"
 #include "rust-system.h"
 #include "rust-token.h"
 #include <memory>
@@ -39,6 +41,17 @@ Builder::literal_string (std::string &&content) const
                          PrimitiveCoreType::CORETYPE_STR, {}, loc));
 }
 
+std::unique_ptr<Expr>
+Builder::literal_bool (bool b) const
+{
+  auto str
+    = b ? Values::Keywords::TRUE_LITERAL : Values::Keywords::FALSE_LITERAL;
+
+  return std::unique_ptr<Expr> (
+    new AST::LiteralExpr (std::move (str), Literal::LitType::BOOL,
+                         PrimitiveCoreType::CORETYPE_BOOL, {}, loc));
+}
+
 std::unique_ptr<Expr>
 Builder::call (std::unique_ptr<Expr> &&path,
               std::vector<std::unique_ptr<Expr>> &&args) const
@@ -279,6 +292,14 @@ Builder::path_in_expression (LangItem::Kind lang_item) const
   return PathInExpression (lang_item, {}, loc);
 }
 
+PathInExpression
+Builder::variant_path (const std::string &enum_path,
+                      const std::string &variant) const
+{
+  return PathInExpression ({path_segment (enum_path), path_segment (variant)},
+                          {}, loc, false);
+}
+
 std::unique_ptr<BlockExpr>
 Builder::block (tl::optional<std::unique_ptr<Stmt>> &&stmt,
                std::unique_ptr<Expr> &&tail_expr) const
@@ -331,6 +352,24 @@ Builder::deref (std::unique_ptr<Expr> &&of) const
   return std::unique_ptr<Expr> (new DereferenceExpr (std::move (of), {}, loc));
 }
 
+std::unique_ptr<Expr>
+Builder::comparison_expr (std::unique_ptr<Expr> &&lhs,
+                         std::unique_ptr<Expr> &&rhs,
+                         ComparisonOperator op) const
+{
+  return std::make_unique<ComparisonExpr> (std::move (lhs), std::move (rhs), op,
+                                          loc);
+}
+
+std::unique_ptr<Expr>
+Builder::boolean_operation (std::unique_ptr<Expr> &&lhs,
+                           std::unique_ptr<Expr> &&rhs,
+                           LazyBooleanOperator op) const
+{
+  return std::make_unique<LazyBooleanExpr> (std::move (lhs), std::move (rhs),
+                                           op, loc);
+}
+
 std::unique_ptr<Stmt>
 Builder::struct_struct (std::string struct_name,
                        std::vector<std::unique_ptr<GenericParam>> &&generics,
@@ -390,6 +429,13 @@ Builder::wildcard () const
   return std::unique_ptr<Pattern> (new WildcardPattern (loc));
 }
 
+std::unique_ptr<Pattern>
+Builder::ref_pattern (std::unique_ptr<Pattern> &&inner) const
+{
+  return std::make_unique<ReferencePattern> (std::move (inner), false, false,
+                                            loc);
+}
+
 std::unique_ptr<Path>
 Builder::lang_item_path (LangItem::Kind kind) const
 {

diff --git a/gcc/rust/ast/rust-ast-builder.h b/gcc/rust/ast/rust-ast-builder.h
index 9fbcea182be66fc9edb94073703c2bd3c31c6b77..faf3cf74df9fd89d7115ffaebf0fb53fb5625696 100644 (file)
--- a/gcc/rust/ast/rust-ast-builder.h
+++ b/gcc/rust/ast/rust-ast-builder.h
@@ -23,6 +23,7 @@
 #include "rust-expr.h"
 #include "rust-ast.h"
 #include "rust-item.h"
+#include "rust-operators.h"
 
 namespace Rust {
 namespace AST {
@@ -62,6 +63,9 @@ public:
   /* Create a string literal expression ("content") */
   std::unique_ptr<Expr> literal_string (std::string &&content) const;
 
+  /* Create a boolean literal expression (true) */
+  std::unique_ptr<Expr> literal_bool (bool b) const;
+
   /* Create an identifier expression (`variable`) */
   std::unique_ptr<Expr> identifier (std::string name) const;
   std::unique_ptr<Pattern> identifier_pattern (std::string name,
@@ -81,6 +85,16 @@ public:
   /* Create a dereference of an expression (`*of`) */
   std::unique_ptr<Expr> deref (std::unique_ptr<Expr> &&of) const;
 
+  /* Build a comparison expression (`lhs == rhs`) */
+  std::unique_ptr<Expr> comparison_expr (std::unique_ptr<Expr> &&lhs,
+                                        std::unique_ptr<Expr> &&rhs,
+                                        ComparisonOperator op) const;
+
+  /* Build a lazy boolean operator expression (`lhs && rhs`) */
+  std::unique_ptr<Expr> boolean_operation (std::unique_ptr<Expr> &&lhs,
+                                          std::unique_ptr<Expr> &&rhs,
+                                          LazyBooleanOperator op) const;
+
   /* Create a block with an optional tail expression */
   std::unique_ptr<BlockExpr> block (std::vector<std::unique_ptr<Stmt>> &&stmts,
                                    std::unique_ptr<Expr> &&tail_expr
@@ -191,6 +205,10 @@ public:
    */
   PathInExpression path_in_expression (LangItem::Kind lang_item) const;
 
+  /* Create the path to an enum's variant (`Result::Ok`) */
+  PathInExpression variant_path (const std::string &enum_path,
+                                const std::string &variant) const;
+
   /* Create a new struct */
   std::unique_ptr<Stmt>
   struct_struct (std::string struct_name,
@@ -223,6 +241,8 @@ public:
 
   /* Create a wildcard pattern (`_`) */
   std::unique_ptr<Pattern> wildcard () const;
+  /* Create a reference pattern (`&pattern`) */
+  std::unique_ptr<Pattern> ref_pattern (std::unique_ptr<Pattern> &&inner) const;
 
   /* Create a lang item path usable as a general path */
   std::unique_ptr<Path> lang_item_path (LangItem::Kind) const;