diff mbox series

[committed,24/88] gccrs: Create and use CompilePatternLet visitor for compiling let statments

Message ID 20230405140411.3016563-25-arthur.cohen@embecosm.com
State Accepted
Headers
Series [committed,01/88] gccrs: fatal_error_flag: Fix typo in error message |

Checks

Context Check Description
snail/gcc-patch-check success Github commit url

Commit Message

Arthur Cohen April 5, 2023, 2:03 p.m. UTC 
  From: Owen Avery <powerboat9.gamer@gmail.com>

gcc/rust/ChangeLog:

	* backend/rust-compile-pattern.cc (CompilePatternLet::visit): New function.
	* backend/rust-compile-stmt.cc (CompileStmt::visit): Likewise.
	* backend/rust-compile-pattern.h (class CompilePatternLet): New visitor.

Signed-off-by: Owen Avery <powerboat9.gamer@gmail.com>
---
 gcc/rust/backend/rust-compile-pattern.cc | 58 ++++++++++++++++
 gcc/rust/backend/rust-compile-pattern.h  | 87 ++++++++++++++++++++++++
 gcc/rust/backend/rust-compile-stmt.cc    | 31 +--------
 3 files changed, 148 insertions(+), 28 deletions(-)
diff mbox series

Patch

diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc
index 9218b815dd8..e13d6caf7e6 100644
--- a/gcc/rust/backend/rust-compile-pattern.cc
+++ b/gcc/rust/backend/rust-compile-pattern.cc
@@ -341,5 +341,63 @@  CompilePatternBindings::visit (HIR::GroupedPattern &pattern)
   pattern.get_item ()->accept_vis (*this);
 }
 
+void
+CompilePatternLet::visit (HIR::IdentifierPattern &pattern)
+{
+  Bvariable *var = nullptr;
+  rust_assert (
+    ctx->lookup_var_decl (pattern.get_pattern_mappings ().get_hirid (), &var));
+
+  auto fnctx = ctx->peek_fn ();
+  if (ty->is_unit ())
+    {
+      ctx->add_statement (init_expr);
+
+      tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
+
+      auto unit_type_init_expr
+	= ctx->get_backend ()->constructor_expression (stmt_type, false, {}, -1,
+						       rval_locus);
+      auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
+						    unit_type_init_expr);
+      ctx->add_statement (s);
+    }
+  else
+    {
+      auto s
+	= ctx->get_backend ()->init_statement (fnctx.fndecl, var, init_expr);
+      ctx->add_statement (s);
+    }
+}
+
+void
+CompilePatternLet::visit (HIR::WildcardPattern &pattern)
+{
+  Bvariable *var = nullptr;
+  rust_assert (
+    ctx->lookup_var_decl (pattern.get_pattern_mappings ().get_hirid (), &var));
+
+  auto fnctx = ctx->peek_fn ();
+  if (ty->is_unit ())
+    {
+      ctx->add_statement (init_expr);
+
+      tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
+
+      auto unit_type_init_expr
+	= ctx->get_backend ()->constructor_expression (stmt_type, false, {}, -1,
+						       rval_locus);
+      auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
+						    unit_type_init_expr);
+      ctx->add_statement (s);
+    }
+  else
+    {
+      auto s
+	= ctx->get_backend ()->init_statement (fnctx.fndecl, var, init_expr);
+      ctx->add_statement (s);
+    }
+}
+
 } // namespace Compile
 } // namespace Rust
diff --git a/gcc/rust/backend/rust-compile-pattern.h b/gcc/rust/backend/rust-compile-pattern.h
index 43334affca7..317a3451161 100644
--- a/gcc/rust/backend/rust-compile-pattern.h
+++ b/gcc/rust/backend/rust-compile-pattern.h
@@ -91,5 +91,92 @@  protected:
   tree match_scrutinee_expr;
 };
 
+class CompilePatternLet : public HIRCompileBase, public HIR::HIRPatternVisitor
+{
+public:
+  static void Compile (HIR::Pattern *pattern, tree init_expr,
+		       TyTy::BaseType *ty, Location rval_locus, Context *ctx)
+  {
+    CompilePatternLet compiler (ctx, init_expr, ty, rval_locus);
+    pattern->accept_vis (compiler);
+  }
+
+  void visit (HIR::IdentifierPattern &) override;
+  void visit (HIR::WildcardPattern &) override;
+
+  // check for unimplemented Pattern HIR nodes.
+  void visit (HIR::GroupedPattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "grouped pattern let statements not supported");
+  }
+
+  void visit (HIR::LiteralPattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "literal pattern let statements not supported");
+  }
+
+  void visit (HIR::PathInExpression &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "path-in-expression pattern let statements not supported");
+  }
+
+  void visit (HIR::QualifiedPathInExpression &pattern) override
+  {
+    rust_sorry_at (
+      pattern.get_locus (),
+      "qualified-path-in-expression pattern let statements not supported");
+  }
+
+  void visit (HIR::RangePattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "range pattern let statements not supported");
+  }
+
+  void visit (HIR::ReferencePattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "reference pattern let statements not supported");
+  }
+
+  void visit (HIR::SlicePattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "slice pattern let statements not supported");
+  }
+
+  void visit (HIR::StructPattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "struct pattern let statements not supported");
+  }
+
+  void visit (HIR::TuplePattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "tuple pattern let statements not supported");
+  }
+
+  void visit (HIR::TupleStructPattern &pattern) override
+  {
+    rust_sorry_at (pattern.get_locus (),
+		   "tuple-struct pattern let statements not supported");
+  }
+
+protected:
+  CompilePatternLet (Context *ctx, tree init_expr, TyTy::BaseType *ty,
+		     Location rval_locus)
+    : HIRCompileBase (ctx), init_expr (init_expr), ty (ty),
+      rval_locus (rval_locus)
+  {}
+
+  tree init_expr;
+  TyTy::BaseType *ty;
+  Location rval_locus;
+};
+
 } // namespace Compile
 } // namespace Rust
diff --git a/gcc/rust/backend/rust-compile-stmt.cc b/gcc/rust/backend/rust-compile-stmt.cc
index 3fc2528ff6b..6bb4ead9451 100644
--- a/gcc/rust/backend/rust-compile-stmt.cc
+++ b/gcc/rust/backend/rust-compile-stmt.cc
@@ -16,6 +16,7 @@ 
 // along with GCC; see the file COPYING3.  If not see
 // <http://www.gnu.org/licenses/>.
 
+#include "rust-compile-pattern.h"
 #include "rust-compile-stmt.h"
 #include "rust-compile-expr.h"
 
@@ -53,7 +54,7 @@  CompileStmt::visit (HIR::LetStmt &stmt)
   if (!stmt.has_init_expr ())
     return;
 
-  const HIR::Pattern &stmt_pattern = *stmt.get_pattern ();
+  HIR::Pattern &stmt_pattern = *stmt.get_pattern ();
   HirId stmt_id = stmt_pattern.get_pattern_mappings ().get_hirid ();
 
   TyTy::BaseType *ty = nullptr;
@@ -65,15 +66,6 @@  CompileStmt::visit (HIR::LetStmt &stmt)
       return;
     }
 
-  Bvariable *var = nullptr;
-  if (!ctx->lookup_var_decl (stmt_id, &var))
-    {
-      // FIXME this should be an assertion instead and use error mark node
-      rust_fatal_error (stmt.get_locus (),
-			"failed to lookup compiled variable declaration");
-      return;
-    }
-
   tree init = CompileExpr::Compile (stmt.get_init_expr (), ctx);
   // FIXME use error_mark_node, check that CompileExpr returns error_mark_node
   // on failure and make this an assertion
@@ -84,7 +76,6 @@  CompileStmt::visit (HIR::LetStmt &stmt)
   bool ok = ctx->get_tyctx ()->lookup_type (
     stmt.get_init_expr ()->get_mappings ().get_hirid (), &actual);
   rust_assert (ok);
-  tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
 
   Location lvalue_locus = stmt.get_pattern ()->get_locus ();
   Location rvalue_locus = stmt.get_init_expr ()->get_locus ();
@@ -92,23 +83,7 @@  CompileStmt::visit (HIR::LetStmt &stmt)
   init = coercion_site (stmt.get_mappings ().get_hirid (), init, actual,
 			expected, lvalue_locus, rvalue_locus);
 
-  auto fnctx = ctx->peek_fn ();
-  if (ty->is_unit ())
-    {
-      ctx->add_statement (init);
-
-      auto unit_type_init_expr
-	= ctx->get_backend ()->constructor_expression (stmt_type, false, {}, -1,
-						       rvalue_locus);
-      auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
-						    unit_type_init_expr);
-      ctx->add_statement (s);
-    }
-  else
-    {
-      auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var, init);
-      ctx->add_statement (s);
-    }
+  CompilePatternLet::Compile (&stmt_pattern, init, ty, rvalue_locus, ctx);
 }
 
 } // namespace Compile