Support deref_mut lang item during method resolution

When we have method resolution we need to look at any deref lang items for
the receiver. The precise rules need to be tested rigorously to ensure this is right.

Fixes #890

Author: philberty

gcc/rust/Make-lang.in

@@ -89,6 +89,7 @@ GRS_OBJS = \
     rust/rust-hir-type-check-type.o \
     rust/rust-hir-type-check-struct.o \
     rust/rust-hir-type-check-pattern.o \
+    rust/rust-hir-dot-operator.o \
     rust/rust-autoderef.o \
     rust/rust-substitution-mapper.o \
     rust/rust-lint-marklive.o \

gcc/rust/backend/rust-compile-base.h

@@ -67,6 +67,9 @@ class HIRCompileBase : public HIR::HIRFullVisitorBase
   tree resolve_deref_adjustment (Resolver::Adjustment &adjustment,
 				 tree expression, Location locus);
 
+  tree resolve_indirection_adjustment (Resolver::Adjustment &adjustment,
+				       tree expression, Location locus);
+
   static void setup_attributes_on_fndecl (
     tree fndecl, bool is_main_entry_point, bool has_visibility,
     const HIR::FunctionQualifiers &qualifiers, const AST::AttrVec &attrs);

gcc/rust/backend/rust-compile-expr.cc

@@ -1199,9 +1199,14 @@ HIRCompileBase::resolve_adjustements (
 	  e = address_expression (e, locus);
 	  break;
 
-	case Resolver::Adjustment::AdjustmentType::DEREF_REF:
+	case Resolver::Adjustment::AdjustmentType::DEREF:
+	case Resolver::Adjustment::AdjustmentType::DEREF_MUT:
 	  e = resolve_deref_adjustment (adjustment, e, locus);
 	  break;
+
+	case Resolver::Adjustment::AdjustmentType::INDIRECTION:
+	  e = resolve_indirection_adjustment (adjustment, e, locus);
+	  break;
 	}
     }
 
@@ -1212,17 +1217,9 @@ tree
 HIRCompileBase::resolve_deref_adjustment (Resolver::Adjustment &adjustment,
 					  tree expression, Location locus)
 {
-  rust_assert (adjustment.is_deref_adjustment ());
-
-  tree expected_type
-    = TyTyResolveCompile::compile (ctx, adjustment.get_expected ());
-  if (!adjustment.has_operator_overload ())
-    {
-      return ctx->get_backend ()->indirect_expression (expected_type,
-						       expression,
-						       true, /* known_valid*/
-						       locus);
-    }
+  rust_assert (adjustment.is_deref_adjustment ()
+	       || adjustment.is_deref_mut_adjustment ());
+  rust_assert (adjustment.has_operator_overload ());
 
   TyTy::FnType *lookup = adjustment.get_deref_operator_fn ();
   HIR::ImplItem *resolved_item = adjustment.get_deref_hir_item ();
@@ -1246,13 +1243,19 @@ HIRCompileBase::resolve_deref_adjustment (Resolver::Adjustment &adjustment,
 
   // make the call
   auto fncontext = ctx->peek_fn ();
-  tree deref_call
-    = ctx->get_backend ()->call_expression (fncontext.fndecl, fn_address,
-					    {adjusted_argument}, nullptr,
-					    locus);
+  return ctx->get_backend ()->call_expression (fncontext.fndecl, fn_address,
+					       {adjusted_argument}, nullptr,
+					       locus);
+}
+
+tree
+HIRCompileBase::resolve_indirection_adjustment (
+  Resolver::Adjustment &adjustment, tree expression, Location locus)
+{
+  tree expected_type
+    = TyTyResolveCompile::compile (ctx, adjustment.get_expected ());
 
-  // do the indirect expression
-  return ctx->get_backend ()->indirect_expression (expected_type, deref_call,
+  return ctx->get_backend ()->indirect_expression (expected_type, expression,
 						   true, /* known_valid*/
 						   locus);
 }

gcc/rust/typecheck/rust-autoderef.cc

@@ -19,6 +19,7 @@
 #include "rust-autoderef.h"
 #include "rust-hir-path-probe.h"
 #include "rust-hir-dot-operator.h"
+#include "rust-hir-trait-resolve.h"
 
 namespace Rust {
 namespace Resolver {
@@ -29,26 +30,6 @@ resolve_operator_overload_fn (
   TyTy::FnType **resolved_fn, HIR::ImplItem **impl_item,
   Adjustment::AdjustmentType *requires_ref_adjustment);
 
-bool
-Adjuster::needs_address (const std::vector<Adjustment> &adjustments)
-{
-  for (auto &adjustment : adjustments)
-    {
-      switch (adjustment.get_type ())
-	{
-	case Adjustment::AdjustmentType::IMM_REF:
-	case Adjustment::AdjustmentType::MUT_REF:
-	case Adjustment::AdjustmentType::DEREF_REF:
-	  return true;
-
-	default:
-	  break;
-	}
-    }
-
-  return false;
-}
-
 TyTy::BaseType *
 Adjuster::adjust_type (const std::vector<Adjustment> &adjustments)
 {
@@ -59,36 +40,64 @@ Adjuster::adjust_type (const std::vector<Adjustment> &adjustments)
 }
 
 Adjustment
-Adjuster::try_deref_type (const TyTy::BaseType *ty)
+Adjuster::try_deref_type (const TyTy::BaseType *ty,
+			  Analysis::RustLangItem::ItemType deref_lang_item)
 {
-  // probe for the lang-item
-  TyTy::BaseType *resolved_base = ty->clone ();
-
   HIR::ImplItem *impl_item = nullptr;
   TyTy::FnType *fn = nullptr;
   Adjustment::AdjustmentType requires_ref_adjustment
     = Adjustment::AdjustmentType::ERROR;
   bool operator_overloaded
-    = resolve_operator_overload_fn (Analysis::RustLangItem::ItemType::DEREF, ty,
-				    &fn, &impl_item, &requires_ref_adjustment);
-  if (operator_overloaded)
+    = resolve_operator_overload_fn (deref_lang_item, ty, &fn, &impl_item,
+				    &requires_ref_adjustment);
+  if (!operator_overloaded)
     {
-      resolved_base = fn->get_return_type ()->clone ();
+      return Adjustment::get_error ();
     }
 
+  auto resolved_base = fn->get_return_type ()->clone ();
   bool is_valid_type = resolved_base->get_kind () == TyTy::TypeKind::REF;
   if (!is_valid_type)
     return Adjustment::get_error ();
 
   TyTy::ReferenceType *ref_base
     = static_cast<TyTy::ReferenceType *> (resolved_base);
 
-  auto infered = ref_base->get_base ()->clone ();
+  Adjustment::AdjustmentType adjustment_type
+    = Adjustment::AdjustmentType::ERROR;
+  switch (deref_lang_item)
+    {
+    case Analysis::RustLangItem::ItemType::DEREF:
+      adjustment_type = Adjustment::AdjustmentType::DEREF;
+      break;
 
-  return Adjustment::get_op_overload_deref_adjustment (infered, fn, impl_item,
+    case Analysis::RustLangItem::ItemType::DEREF_MUT:
+      adjustment_type = Adjustment::AdjustmentType::DEREF_MUT;
+      break;
+
+    default:
+      break;
+    }
+
+  return Adjustment::get_op_overload_deref_adjustment (adjustment_type,
+						       ref_base, fn, impl_item,
 						       requires_ref_adjustment);
 }
 
+Adjustment
+Adjuster::try_raw_deref_type (const TyTy::BaseType *ty)
+{
+  bool is_valid_type = ty->get_kind () == TyTy::TypeKind::REF;
+  if (!is_valid_type)
+    return Adjustment::get_error ();
+
+  const TyTy::ReferenceType *ref_base
+    = static_cast<const TyTy::ReferenceType *> (ty);
+  auto infered = ref_base->get_base ()->clone ();
+
+  return Adjustment (Adjustment::AdjustmentType::INDIRECTION, infered);
+}
+
 static bool
 resolve_operator_overload_fn (
   Analysis::RustLangItem::ItemType lang_item_type, const TyTy::BaseType *ty,

gcc/rust/typecheck/rust-autoderef.h

@@ -33,7 +33,9 @@ class Adjustment
 
     IMM_REF,
     MUT_REF,
-    DEREF_REF
+    DEREF,
+    DEREF_MUT,
+    INDIRECTION,
   };
 
   // ctor for all adjustments except derefs
@@ -42,11 +44,12 @@ class Adjustment
   {}
 
   static Adjustment get_op_overload_deref_adjustment (
-    const TyTy::BaseType *expected, TyTy::FnType *fn, HIR::ImplItem *deref_item,
+    AdjustmentType type, const TyTy::BaseType *expected, TyTy::FnType *fn,
+    HIR::ImplItem *deref_item,
     Adjustment::AdjustmentType requires_ref_adjustment)
   {
-    return Adjustment (Adjustment::DEREF_REF, expected, fn, deref_item,
-		       requires_ref_adjustment);
+    rust_assert (type == DEREF || type == DEREF_MUT);
+    return Adjustment (type, expected, fn, deref_item, requires_ref_adjustment);
   }
 
   AdjustmentType get_type () const { return type; }
@@ -69,8 +72,12 @@ class Adjustment
 	return "IMM_REF";
       case AdjustmentType::MUT_REF:
 	return "MUT_REF";
-      case AdjustmentType::DEREF_REF:
-	return "DEREF_REF";
+      case AdjustmentType::DEREF:
+	return "DEREF";
+      case AdjustmentType::DEREF_MUT:
+	return "DEREF_MUT";
+      case AdjustmentType::INDIRECTION:
+	return "INDIRECTION";
       }
     gcc_unreachable ();
     return "";
@@ -80,7 +87,9 @@ class Adjustment
 
   bool is_error () const { return type == ERROR; }
 
-  bool is_deref_adjustment () const { return type == DEREF_REF; }
+  bool is_deref_adjustment () const { return type == DEREF; }
+
+  bool is_deref_mut_adjustment () const { return type == DEREF_MUT; }
 
   bool has_operator_overload () const { return deref_operator_fn != nullptr; }
 
@@ -120,9 +129,11 @@ class Adjuster
 
   TyTy::BaseType *adjust_type (const std::vector<Adjustment> &adjustments);
 
-  static bool needs_address (const std::vector<Adjustment> &adjustments);
+  static Adjustment
+  try_deref_type (const TyTy::BaseType *ty,
+		  Analysis::RustLangItem::ItemType deref_lang_item);
 
-  static Adjustment try_deref_type (const TyTy::BaseType *ty);
+  static Adjustment try_raw_deref_type (const TyTy::BaseType *ty);
 
 private:
   const TyTy::BaseType *base;