Merge #817

817: Remove bad mutability check pass r=philberty a=philberty

This was an initial pass to try and ensure all assignments were valid
with respect to the binding mutability. This pass cannot be done at the
name resolution level and in rustc is achieved on mir as part of the borrow
checker. This patch removes this pass and associated test cases.

This set of patches also adds support for indirection around array index
expressions.

Fixes #815 

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

5 files changed, 46 insertions, 28 deletions

diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h
index 2bf969b..46d501a 100644
--- a/gcc/rust/backend/rust-compile-expr.h
+++ b/gcc/rust/backend/rust-compile-expr.h
@@ -390,10 +390,32 @@ public:
 
   void visit (HIR::ArrayIndexExpr &expr) override
   {
-    tree array = CompileExpr::Compile (expr.get_array_expr (), ctx);
+    tree array_reference = CompileExpr::Compile (expr.get_array_expr (), ctx);
     tree index = CompileExpr::Compile (expr.get_index_expr (), ctx);
+
+    // lets check if the array is a reference type then we can add an
+    // indirection if required
+    TyTy::BaseType *array_expr_ty = nullptr;
+    bool ok = ctx->get_tyctx ()->lookup_type (
+      expr.get_array_expr ()->get_mappings ().get_hirid (), &array_expr_ty);
+    rust_assert (ok);
+
+    // do we need to add an indirect reference
+    if (array_expr_ty->get_kind () == TyTy::TypeKind::REF)
+      {
+	TyTy::ReferenceType *r
+	  = static_cast<TyTy::ReferenceType *> (array_expr_ty);
+	TyTy::BaseType *tuple_type = r->get_base ();
+	tree array_tyty = TyTyResolveCompile::compile (ctx, tuple_type);
+
+	array_reference
+	  = ctx->get_backend ()->indirect_expression (array_tyty,
+						      array_reference, true,
+						      expr.get_locus ());
+      }
+
     translated
-      = ctx->get_backend ()->array_index_expression (array, index,
+      = ctx->get_backend ()->array_index_expression (array_reference, index,
 						     expr.get_locus ());
   }
 
diff --git a/gcc/rust/hir/rust-ast-lower-implitem.h b/gcc/rust/hir/rust-ast-lower-implitem.h
index 8f9c5d5..3613df5 100644
--- a/gcc/rust/hir/rust-ast-lower-implitem.h
+++ b/gcc/rust/hir/rust-ast-lower-implitem.h
@@ -153,7 +153,7 @@ public:
 	  = HIR::FunctionParam (mapping, std::move (translated_pattern),
 				std::move (translated_type),
 				param.get_locus ());
-	function_params.push_back (hir_param);
+	function_params.push_back (std::move (hir_param));
       }
 
     bool terminated = false;
@@ -239,7 +239,7 @@ public:
 	  = HIR::FunctionParam (mapping, std::move (translated_pattern),
 				std::move (translated_type),
 				param.get_locus ());
-	function_params.push_back (hir_param);
+	function_params.push_back (std::move (hir_param));
       }
 
     bool terminated = false;
@@ -345,7 +345,7 @@ public:
 	  = HIR::FunctionParam (mapping, std::move (translated_pattern),
 				std::move (translated_type),
 				param.get_locus ());
-	function_params.push_back (hir_param);
+	function_params.push_back (std::move (hir_param));
       }
 
     HIR::TraitFunctionDecl decl (ref.get_identifier (), std::move (qualifiers),
diff --git a/gcc/rust/hir/rust-ast-lower-item.h b/gcc/rust/hir/rust-ast-lower-item.h
index 65a4921..697e98a 100644
--- a/gcc/rust/hir/rust-ast-lower-item.h
+++ b/gcc/rust/hir/rust-ast-lower-item.h
@@ -465,7 +465,7 @@ public:
 	  = HIR::FunctionParam (mapping, std::move (translated_pattern),
 				std::move (translated_type),
 				param.get_locus ());
-	function_params.push_back (hir_param);
+	function_params.push_back (std::move (hir_param));
       }
 
     bool terminated = false;
diff --git a/gcc/rust/resolve/rust-ast-verify-assignee.h b/gcc/rust/resolve/rust-ast-verify-assignee.h
index d362fe4..e9f6f23 100644
--- a/gcc/rust/resolve/rust-ast-verify-assignee.h
+++ b/gcc/rust/resolve/rust-ast-verify-assignee.h
@@ -65,14 +65,6 @@ public:
     ok = true;
     // mark the assignment to the name
     resolver->mark_assignment_to_decl (resolved_node, parent);
-
-    // check is mutable
-    if (!resolver->decl_is_mutable (resolved_node))
-      {
-	// we only allow a single assignment to immutable decls
-	if (resolver->get_num_assignments_to_decl (resolved_node) > 1)
-	  rust_error_at (expr.get_locus (), "cannot assign to immutable");
-      }
   }
 
   void visit (AST::DereferenceExpr &expr) override
diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h
index fb1cd97..8c34b6c 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h
@@ -929,24 +929,27 @@ public:
 
     auto resolved_index_expr
       = size_ty->unify (TypeCheckExpr::Resolve (expr.get_index_expr (), false));
-    if (resolved_index_expr == nullptr)
+    if (resolved_index_expr->get_kind () != TyTy::TypeKind::ERROR)
       {
-	rust_error_at (expr.get_index_expr ()->get_locus (),
-		       "Type Resolver failure in Index for ArrayIndexExpr");
-	return;
+	// allow the index expr to fail lets just continue on
+	context->insert_type (expr.get_index_expr ()->get_mappings (),
+			      resolved_index_expr);
       }
-    context->insert_type (expr.get_index_expr ()->get_mappings (),
-			  resolved_index_expr);
 
-    // resolve the array reference
-    expr.get_array_expr ()->accept_vis (*this);
-    if (infered == nullptr)
+    auto array_expr_ty
+      = TypeCheckExpr::Resolve (expr.get_array_expr (), inside_loop);
+    if (array_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
+      return;
+    else if (array_expr_ty->get_kind () == TyTy::TypeKind::REF)
       {
-	rust_error_at (expr.get_index_expr ()->get_locus (),
-		       "failed to resolve array reference expression");
-	return;
+	// lets try and deref it since rust allows this
+	auto ref = static_cast<TyTy::ReferenceType *> (array_expr_ty);
+	auto base = ref->get_base ();
+	if (base->get_kind () == TyTy::TypeKind::ARRAY)
+	  array_expr_ty = base;
       }
-    else if (infered->get_kind () != TyTy::TypeKind::ARRAY)
+
+    if (array_expr_ty->get_kind () != TyTy::TypeKind::ARRAY)
       {
 	rust_error_at (expr.get_index_expr ()->get_locus (),
 		       "expected an ArrayType got [%s]",
@@ -955,7 +958,8 @@ public:
 	return;
       }
 
-    TyTy::ArrayType *array_type = static_cast<TyTy::ArrayType *> (infered);
+    TyTy::ArrayType *array_type
+      = static_cast<TyTy::ArrayType *> (array_expr_ty);
     infered = array_type->get_element_type ()->clone ();
   }