Merge #920

920: Support deref_mut lang item during method resolution r=philberty a=philberty

This adds in the lookups for the DEREF_MUT lang item for operator overloading
this needs more testing to ensure the behaviour is correct and is the same as
rustc.

Fixes #890


Co-authored-by: Philip Herron <[email protected]>

Author: bors[bot]

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;