gccrs: Emit error when borrowing immutable variable as mutable

Fixes #4289

Rust rules strictly forbid creating a mutable reference ('&mut T') to an
immutable binding. Previously, the compiler failed to validate the
mutability of the source variable when using a 'ref mut' pattern.
This patch adds verification logic to TypeCheckStmt to check the
mutability status of the variable definition.

gcc/rust/ChangeLog:

	* typecheck/rust-hir-type-check-stmt.cc (TypeCheckStmt::visit):
	Add check to ensure 'ref mut' patterns bind to mutable variables.

gcc/testsuite/ChangeLog:

	* rust/compile/issue-4289.rs: New test.

Signed-off-by: Jayant Chauhan <0001jayant@gmail.com>

Author: Pasta-coder

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

@@ -84,10 +84,91 @@ TypeCheckStmt::visit (HIR::LetStmt &stmt)
   auto &stmt_pattern = stmt.get_pattern ();
   TyTy::BaseType *init_expr_ty = nullptr;
   location_t init_expr_locus = UNKNOWN_LOCATION;
+
   if (stmt.has_init_expr ())
     {
-      init_expr_locus = stmt.get_init_expr ().get_locus ();
-      init_expr_ty = TypeCheckExpr::Resolve (stmt.get_init_expr ());
+      HIR::Expr &init = stmt.get_init_expr ();
+      init_expr_locus = init.get_locus ();
+      init_expr_ty = TypeCheckExpr::Resolve (init);
+
+      if (stmt_pattern.get_pattern_type ()
+	  == HIR::Pattern::PatternType::IDENTIFIER)
+	{
+	  auto &ident = static_cast<HIR::IdentifierPattern &> (stmt_pattern);
+
+	  if (ident.get_is_ref () && ident.is_mut ())
+	    {
+	      NodeId def_id = UNKNOWN_NODEID;
+	      bool found = false;
+	      auto resolver = Rust::Resolver::Resolver::get ();
+
+	      if (init.get_expression_type () == HIR::Expr::ExprType::Path)
+		{
+		  auto &path_expr = static_cast<HIR::PathInExpression &> (init);
+
+		  if (resolver->lookup_resolved_name (
+			path_expr.get_mappings ().get_nodeid (), &def_id))
+		    {
+		      found = true;
+		    }
+		  else if (path_expr.get_segments ().size () > 0)
+		    {
+		      NodeId segment_id = path_expr.get_segments ()
+					    .back ()
+					    .get_mappings ()
+					    .get_nodeid ();
+		      if (resolver->lookup_resolved_name (segment_id, &def_id))
+			{
+			  found = true;
+			}
+		    }
+		}
+
+	      if (!found
+		  && resolver->lookup_resolved_name (
+		    init.get_mappings ().get_nodeid (), &def_id))
+		{
+		  found = true;
+		}
+
+	      if (found)
+		{
+		  bool is_mutable = false;
+		  auto &mappings = Analysis::Mappings::get ();
+
+		  auto result_hir_id = mappings.lookup_node_to_hir (def_id);
+		  if (result_hir_id.has_value ())
+		    {
+		      HirId var_hir_id = result_hir_id.value ();
+		      auto result_pattern
+			= mappings.lookup_hir_pattern (var_hir_id);
+
+		      if (result_pattern.has_value ())
+			{
+			  HIR::Pattern *def_pattern = result_pattern.value ();
+
+			  if (def_pattern
+			      && def_pattern->get_pattern_type ()
+				   == HIR::Pattern::PatternType::IDENTIFIER)
+			    {
+			      auto def_ident
+				= static_cast<HIR::IdentifierPattern *> (
+				  def_pattern);
+
+			      if (def_ident->is_mut ())
+				is_mutable = true;
+			    }
+			}
+		    }
+
+		  if (!is_mutable)
+		    rust_error_at (
+		      stmt_pattern.get_locus (),
+		      "cannot borrow immutable local variable as mutable");
+		}
+	    }
+	}
+
       if (init_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
 	return;
 

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

@@ -0,0 +1,10 @@
+// { dg-options "-fsyntax-only" }
+pub fn a() {
+    let v = 10;
+    let ref mut r = v; // { dg-error "cannot borrow immutable local variable as mutable" }
+}
+
+pub fn b() {
+    let mut v2 = 10;
+    let ref mut r2 = v2; // Should compile fine
+}