gccrs: Implement type check & codegen for HIR::StructPatternFieldTuplePat

006t.original dump of rust/compile/match-structpattern-tuplefield.rs:

...
  const struct match_structpattern_tuplefield::TupStruct t = {.0=1, .1=2};
    struct () RUSTTMP.1;
    const struct match_structpattern_tuplefield::TupStruct RUSTTMP.2;
  RUSTTMP.2 = t;
  if (RUSTTMP.2.0 == 1 && RUSTTMP.2.1 == 2)
    {
      {
                struct () RUSTTMP.3;
        {}
        goto <D.100>;
      }
    }
  if (1)
    {
      {
                struct () RUSTTMP.4;
        {}
        goto <D.100>;
      }
    }
  if (RUSTTMP.2.0 == 1)
    {
      {
                struct () RUSTTMP.5;
        {}
        goto <D.100>;
      }
    }
  if (1)
    {
      {
                struct () RUSTTMP.6;
        {}
        goto <D.100>;
      }
    }
  <D.100>:;
...

gcc/rust/ChangeLog:

	* typecheck/rust-hir-type-check-pattern.cc (visit(StructPattern)): Implement
	type check case for HIR::StructPatternFieldTuplePat.
	* checks/errors/rust-hir-pattern-analysis.cc (lower_struct_pattern): Implement
	case for HIR::StructPatternField::ItemType::TUPLE_PAT.
	* backend/rust-compile-pattern.cc:
		* CompilePatternCheckExpr::visit (HIR::StructPattern): Implement code
		gen for HIR::StructPatternField::ItemType::TUPLE_PAT case.
		* CompilePatternBindings::handle_struct_pattern_tuple_pat: Implement
		bindings for HIR::StructPatternFieldTuplePat.
	* backend/rust-compile-pattern.h: Update function definition for
	handle_struct_pattern_tuple_pat.

Signed-off-by: Yap Zhi Heng <yapzhhg@gmail.com>

diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc
index 3836aa2af5570c5d725171c56f788d9e448cc393..d57616e6d09551d40e0312b4d8bedf4f664c3feb 100644 (file)
--- a/gcc/rust/backend/rust-compile-pattern.cc
+++ b/gcc/rust/backend/rust-compile-pattern.cc
@@ -297,8 +297,18 @@ CompilePatternCheckExpr::visit (HIR::StructPattern &pattern)
        {
        case HIR::StructPatternField::ItemType::TUPLE_PAT:
          {
-           // TODO
-           rust_unreachable ();
+           HIR::StructPatternFieldTuplePat &tuple_pat
+             = static_cast<HIR::StructPatternFieldTuplePat &> (*field.get ());
+           size_t tuple_pat_index = tuple_pat.get_index ();
+           tree field_expr
+             = Backend::struct_field_expression (variant_accesser_expr,
+                                                 tuple_pat_index,
+                                                 tuple_pat.get_locus ());
+           tree check_expr_sub = CompilePatternCheckExpr::Compile (
+             tuple_pat.get_tuple_pattern (), field_expr, ctx);
+           check_expr = Backend::arithmetic_or_logical_expression (
+             ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
+             check_expr_sub, tuple_pat.get_locus ());
          }
          break;
 
@@ -954,9 +964,40 @@ CompilePatternBindings::handle_struct_pattern_ident_pat (
 
 void
 CompilePatternBindings::handle_struct_pattern_tuple_pat (
-  HIR::StructPatternField &pat)
+  HIR::StructPatternField &pat, TyTy::ADTType *adt, TyTy::VariantDef *variant,
+  int variant_index)
 {
-  rust_unreachable ();
+  HIR::StructPatternFieldTuplePat &tuple_pat
+    = static_cast<HIR::StructPatternFieldTuplePat &> (pat);
+
+  size_t tuple_pat_index = tuple_pat.get_index ();
+  tree binding;
+
+  if (adt->is_enum ())
+    {
+      tree payload_accessor_union
+       = Backend::struct_field_expression (match_scrutinee_expr, 1,
+                                           pat.get_locus ());
+
+      tree variant_accessor
+       = Backend::struct_field_expression (payload_accessor_union,
+                                           variant_index, pat.get_locus ());
+
+      binding
+       = Backend::struct_field_expression (variant_accessor, tuple_pat_index,
+                                           pat.get_locus ());
+    }
+  else
+    {
+      tree variant_accessor = match_scrutinee_expr;
+
+      binding
+       = Backend::struct_field_expression (variant_accessor, tuple_pat_index,
+                                           pat.get_locus ());
+    }
+
+  CompilePatternBindings::Compile (tuple_pat.get_tuple_pattern (), binding,
+                                  ctx);
 }
 
 void
@@ -996,7 +1037,7 @@ CompilePatternBindings::visit (HIR::StructPattern &pattern)
       switch (field->get_item_type ())
        {
        case HIR::StructPatternField::ItemType::TUPLE_PAT:
-         handle_struct_pattern_tuple_pat (*field);
+         handle_struct_pattern_tuple_pat (*field, adt, variant, variant_index);
          break;
        case HIR::StructPatternField::ItemType::IDENT_PAT:
          handle_struct_pattern_ident_pat (*field, adt, variant, variant_index);

diff --git a/gcc/rust/backend/rust-compile-pattern.h b/gcc/rust/backend/rust-compile-pattern.h
index 7c38eb5717b0b96368225de49ef21d6724c7feeb..35e152fe3b189cc54bb15d0ff0ee2a3fbc856970 100644 (file)
--- a/gcc/rust/backend/rust-compile-pattern.h
+++ b/gcc/rust/backend/rust-compile-pattern.h
@@ -88,7 +88,10 @@ public:
                                        TyTy::ADTType *adt,
                                        TyTy::VariantDef *variant,
                                        int variant_index);
-  void handle_struct_pattern_tuple_pat (HIR::StructPatternField &pat);
+  void handle_struct_pattern_tuple_pat (HIR::StructPatternField &pat,
+                                       TyTy::ADTType *adt,
+                                       TyTy::VariantDef *variant,
+                                       int variant_index);
 
   void visit (HIR::StructPattern &pattern) override;
   void visit (HIR::TupleStructPattern &pattern) override;

diff --git a/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc b/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc
index 8c972a596471e0c0d6bfefbc002bf5342e048e30..431cd9bb891f394c0bf237a06edf65ff9f198d97 100644 (file)
--- a/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc
+++ b/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc
@@ -1315,8 +1315,12 @@ lower_struct_pattern (Resolver::TypeCheckContext *ctx,
          break;
        case HIR::StructPatternField::ItemType::TUPLE_PAT:
          {
-           // TODO: tuple: pat
-           rust_unreachable ();
+           HIR::StructPatternFieldTuplePat *tuple_pat
+             = static_cast<HIR::StructPatternFieldTuplePat *> (elem.get ());
+           int field_idx = tuple_pat->get_index ();
+           fields.at (field_idx) = lower_pattern (
+             ctx, tuple_pat->get_tuple_pattern (),
+             variant->get_fields ().at (field_idx)->get_field_type ());
          }
          break;
        default:

diff --git a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
index 1e043d73740693340f8defddc272f41cda0726bb..4f484ca0d9d28a125e09e54376b6f024169e6f71 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
@@ -474,8 +474,21 @@ TypeCheckPattern::visit (HIR::StructPattern &pattern)
        {
        case HIR::StructPatternField::ItemType::TUPLE_PAT:
          {
-           // TODO
-           rust_unreachable ();
+           HIR::StructPatternFieldTuplePat &tuple_pat
+             = static_cast<HIR::StructPatternFieldTuplePat &> (*field.get ());
+
+           if ((size_t) tuple_pat.get_index () >= variant->num_fields ())
+             {
+               emit_invalid_field_error (tuple_pat.get_locus (), variant,
+                                         std::to_string (
+                                           tuple_pat.get_index ()));
+               break;
+             }
+           named_fields.push_back (std::to_string (tuple_pat.get_index ()));
+           TyTy::StructFieldType *field
+             = variant->get_field_at_index (tuple_pat.get_index ());
+           TyTy::BaseType *fty = field->get_field_type ();
+           TypeCheckPattern::Resolve (tuple_pat.get_tuple_pattern (), fty);
          }
          break;
 

diff --git a/gcc/testsuite/rust/compile/match-structpattern-tuplefield-err.rs b/gcc/testsuite/rust/compile/match-structpattern-tuplefield-err.rs
new file mode 100644 (file)
index 0000000..ca4fb1a
--- /dev/null
+++ b/gcc/testsuite/rust/compile/match-structpattern-tuplefield-err.rs
@@ -0,0 +1,17 @@
+pub struct TupStruct (i32, i32);
+
+pub fn main() {
+    let t = TupStruct (1, 2);
+    match t {
+        TupStruct { 0: 1, 1: 2, 2: 3 } => {}
+        // { dg-error "variant TupStruct does not have a field named 2 .E0026." "" { target *-*-* } .-1 }
+        TupStruct { 3: 3 } => {}
+        // { dg-error "pattern does not mention fields 0, 1 .E0027." "" { target *-*-* } .-1 }
+        // { dg-error "variant TupStruct does not have a field named 3 .E0026." "" { target *-*-* } .-2 }
+        TupStruct { a: 3 } => {}
+        // { dg-error "tuple variant .TupStruct. written as struct variant .E0769." "" { target *-*-* } .-1 }
+        TupStruct { 0: 0.1f32, .. } => {}
+        // { dg-error "mismatched types, expected .i32. but got .f32. .E0308." "" { target *-*-* } .-1 }
+        _ => {}
+    }
+}

diff --git a/gcc/testsuite/rust/compile/match-structpattern-tuplefield.rs b/gcc/testsuite/rust/compile/match-structpattern-tuplefield.rs
new file mode 100644 (file)
index 0000000..8807e98
--- /dev/null
+++ b/gcc/testsuite/rust/compile/match-structpattern-tuplefield.rs
@@ -0,0 +1,11 @@
+pub struct TupStruct (i32, i32);
+
+pub fn main() {
+    let t = TupStruct (1, 2);
+    match t {
+        TupStruct { 0: 1, 1: 2 } => {}
+        TupStruct { 1: b, .. } => {}
+        TupStruct { 0: 1, .. } => {}
+        _ => {}
+    }
+}

diff --git a/gcc/testsuite/rust/execute/torture/match-structpattern-tuplefield.rs b/gcc/testsuite/rust/execute/torture/match-structpattern-tuplefield.rs
new file mode 100644 (file)
index 0000000..3c66575
--- /dev/null
+++ b/gcc/testsuite/rust/execute/torture/match-structpattern-tuplefield.rs
@@ -0,0 +1,10 @@
+pub struct TupStruct (i32, i32);
+
+pub fn main() -> i32 {
+    let mut t = TupStruct (1, 1);
+    match t {
+        TupStruct { 0: 1, 1: b } => { b -= 1 }
+        _ => {}
+    }
+    b
+}