Merge branch 'master' into fix-no-input-segfault-v2

Author: shreyas-omkar

gcc/rust/typecheck/rust-hir-type-check-base.cc

@@ -412,7 +412,7 @@ TypeCheckBase::parse_repr_options (const AST::AttrVec &attrs, location_t locus)
       bool is_repr = attr.get_path ().as_string () == Values::Attributes::REPR;
       if (is_repr && !attr.has_attr_input ())
 	{
-	  rust_error_at (attr.get_locus (), "malformed %qs attribute", "repr");
+	  rust_error_at (attr.get_locus (), "malformed %<repr%> attribute");
 	  continue;
 	}
 
@@ -421,7 +421,11 @@ TypeCheckBase::parse_repr_options (const AST::AttrVec &attrs, location_t locus)
 	  const AST::AttrInput &input = attr.get_attr_input ();
 	  bool is_token_tree = input.get_attr_input_type ()
 			       == AST::AttrInput::AttrInputType::TOKEN_TREE;
-	  rust_assert (is_token_tree);
+	  if (!is_token_tree)
+	    {
+	      rust_error_at (attr.get_locus (), "malformed %<repr%> attribute");
+	      continue;
+	    }
 	  const auto &option = static_cast<const AST::DelimTokenTree &> (input);
 	  AST::AttrInputMetaItemContainer *meta_items
 	    = option.parse_to_meta_item ();

gcc/rust/typecheck/rust-hir-type-check-pattern.cc

@@ -162,19 +162,32 @@ TypeCheckPattern::visit (HIR::TupleStructPattern &pattern)
 
   infered = pattern_ty;
   TyTy::ADTType *adt = static_cast<TyTy::ADTType *> (infered);
-  rust_assert (adt->number_of_variants () > 0);
 
-  TyTy::VariantDef *variant = adt->get_variants ().at (0);
+  TyTy::VariantDef *variant = nullptr;
   if (adt->is_enum ())
     {
       HirId variant_id = UNKNOWN_HIRID;
       bool ok = context->lookup_variant_definition (
 	pattern.get_path ().get_mappings ().get_hirid (), &variant_id);
-      rust_assert (ok);
+      if (!ok)
+	{
+	  rust_error_at (
+	    pattern.get_locus (), ErrorCode::E0532,
+	    "expected tuple struct or tuple variant, found enum %qs",
+	    pattern_ty->get_name ().c_str ());
+	  return;
+	}
 
       ok = adt->lookup_variant_by_id (variant_id, &variant);
       rust_assert (ok);
     }
+  else
+    {
+      rust_assert (adt->number_of_variants () > 0);
+      variant = adt->get_variants ().at (0);
+    }
+
+  rust_assert (variant != nullptr);
 
   // error[E0532]: expected tuple struct or tuple variant, found struct
   // variant `Foo::D`, E0532 by rustc 1.49.0 , E0164 by rustc 1.71.0
@@ -644,14 +657,14 @@ TypeCheckPattern::visit (HIR::TuplePattern &pattern)
 	  {
 	    emit_pattern_size_error (pattern, par.get_fields ().size (),
 				     min_size_required);
-	    // TODO attempt to continue to do typechecking even after wrong
-	    // size
-	    break;
+	    // continue and attempt to resolve individual items in the pattern
 	  }
 
 	// Resolve lower patterns
 	std::vector<TyTy::TyVar> pattern_elems;
-	for (size_t i = 0; i < lower.size (); i++)
+	size_t nlower_items_to_resolve
+	  = std::min (lower.size (), par.get_fields ().size ());
+	for (size_t i = 0; i < nlower_items_to_resolve; i++)
 	  {
 	    auto &p = lower[i];
 	    TyTy::BaseType *par_type = par.get_field (i);
@@ -660,16 +673,23 @@ TypeCheckPattern::visit (HIR::TuplePattern &pattern)
 	    pattern_elems.emplace_back (elem->get_ref ());
 	  }
 
+	if (lower.size () > par.get_fields ().size ())
+	  break;
+
 	// Pad pattern_elems until needing to resolve upper patterns
-	size_t rest_end = par.get_fields ().size () - upper.size ();
+	size_t rest_end
+	  = std::max (par.get_fields ().size () - upper.size (), lower.size ());
 	for (size_t i = lower.size (); i < rest_end; i++)
 	  {
 	    TyTy::BaseType *par_type = par.get_field (i);
 	    pattern_elems.emplace_back (par_type->get_ref ());
 	  }
 
+	size_t nupper_items_to_resolve
+	  = std::min (upper.size (),
+		      par.get_fields ().size () - pattern_elems.size ());
 	// Resolve upper patterns
-	for (size_t i = 0; i < upper.size (); i++)
+	for (size_t i = 0; i < nupper_items_to_resolve; i++)
 	  {
 	    auto &p = upper[i];
 	    TyTy::BaseType *par_type = par.get_field (rest_end + i);

gcc/testsuite/rust/compile/issue-4231.rs

@@ -0,0 +1,6 @@
+#[repr = ""] // { dg-error "malformed .repr. attribute" }
+struct ThreeInts {
+    first: i16,
+    second: i8,
+    third: i32
+}

gcc/testsuite/rust/compile/match-tuplestructpattern-non-variant.rs

@@ -0,0 +1,20 @@
+enum Empty {}
+enum NonEmpty {
+    Foo(i32),
+}
+
+fn f(e: Empty) {
+    match e { 
+        Empty(0) => {} // { dg-error "expected tuple struct or tuple variant, found enum 'Empty'" }
+    }
+
+    match e {
+        Empty(Empty(..)) => {} // { dg-error "expected tuple struct or tuple variant, found enum 'Empty'" }
+    }
+}
+
+fn g(e: NonEmpty) {
+    match e {
+        NonEmpty(0) => {} // { dg-error "expected tuple struct or tuple variant, found enum 'NonEmpty'" }
+    }
+}

gcc/testsuite/rust/compile/tuplepattern-restpattern-typecheck-err.rs

@@ -0,0 +1,8 @@
+fn main() {
+    match (1, 2.2, "not 3") {
+        // { dg-error "expected a tuple with 3 elements, found one with 5 elements" "" { target *-*-* } .+1 }
+        (a, b, .., c, d, e) => {
+            let _ = b + c; // { dg-error "cannot apply operator .+. to types <float> and & str" }
+        }
+    }
+}