gccrs: Fix method resolution to use TryCoerce

Rust allows us to call generic pointer methods on pointers so in non
generic contexts the old code using the bad can_eq interface couldn't
handle this case. So taking advantage of our new unify_and interface to try
and infer when required we can start using our TryCoerce interface to reuse
existing code to assemble possible candidates more acurately using the
existing coercion rules.

Fixes #1901 #878

Signed-off-by: Philip Herron <[email protected]>

gcc/rust/ChangeLog:

	* typecheck/rust-coercion.cc (TypeCoercionRules::Coerce): Add new try_flag
	(TypeCoercionRules::TypeCoercionRules): set new try flag
	(TypeCoercionRules::do_coercion): default to a final unify_and in the else case
	(TypeCoercionRules::coerce_unsafe_ptr): cannot coerce to a ptr from ref during autoderef
	(TypeCoercionRules::coerce_borrowed_pointer): respect coerceable mutability
	* typecheck/rust-coercion.h: update header
	* typecheck/rust-hir-dot-operator.cc (MethodResolver::select): use new TryCoerce interface
	(MethodResolver::append_adjustments): ensure we maintain adjustment mappings
	* typecheck/rust-hir-dot-operator.h: add new method append_adjustments
	* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): extra logging

gcc/testsuite/ChangeLog:

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

Author: philberty

gcc/rust/typecheck/rust-coercion.cc

@@ -27,7 +27,7 @@ TypeCoercionRules::CoercionResult
 TypeCoercionRules::Coerce (TyTy::BaseType *receiver, TyTy::BaseType *expected,
 			   Location locus, bool allow_autoderef)
 {
-  TypeCoercionRules resolver (expected, locus, true, allow_autoderef);
+  TypeCoercionRules resolver (expected, locus, true, allow_autoderef, false);
   bool ok = resolver.do_coercion (receiver);
   return ok ? resolver.try_result : CoercionResult::get_error ();
 }
@@ -37,16 +37,18 @@ TypeCoercionRules::TryCoerce (TyTy::BaseType *receiver,
 			      TyTy::BaseType *expected, Location locus,
 			      bool allow_autoderef)
 {
-  TypeCoercionRules resolver (expected, locus, false, allow_autoderef);
+  TypeCoercionRules resolver (expected, locus, false, allow_autoderef, true);
   bool ok = resolver.do_coercion (receiver);
   return ok ? resolver.try_result : CoercionResult::get_error ();
 }
 
 TypeCoercionRules::TypeCoercionRules (TyTy::BaseType *expected, Location locus,
-				      bool emit_errors, bool allow_autoderef)
+				      bool emit_errors, bool allow_autoderef,
+				      bool try_flag)
   : AutoderefCycle (!allow_autoderef), mappings (Analysis::Mappings::get ()),
     context (TypeCheckContext::get ()), expected (expected), locus (locus),
-    try_result (CoercionResult::get_error ()), emit_errors (emit_errors)
+    try_result (CoercionResult::get_error ()), emit_errors (emit_errors),
+    try_flag (try_flag)
 {}
 
 bool
@@ -139,6 +141,31 @@ TypeCoercionRules::do_coercion (TyTy::BaseType *receiver)
       break;
     }
 
+  // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/coercion.rs#L210
+  switch (receiver->get_kind ())
+    {
+      default: {
+	rust_debug (
+	  "do_coercion default unify and infer expected: %s receiver %s",
+	  receiver->debug_str ().c_str (), expected->debug_str ().c_str ());
+	TyTy::BaseType *result
+	  = unify_site_and (receiver->get_ref (),
+			    TyTy::TyWithLocation (expected),
+			    TyTy::TyWithLocation (receiver),
+			    locus /*unify_locus*/, false /*emit_errors*/,
+			    !try_flag /*commit_if_ok*/, true /*infer*/,
+			    try_flag /*cleanup on error*/);
+	rust_debug ("result");
+	result->debug ();
+	if (result->get_kind () != TyTy::TypeKind::ERROR)
+	  {
+	    try_result = CoercionResult{{}, result};
+	    return true;
+	  }
+      }
+      break;
+    }
+
   return !try_result.is_error ();
 }
 
@@ -170,13 +197,21 @@ TypeCoercionRules::coerce_unsafe_ptr (TyTy::BaseType *receiver,
       break;
 
       default: {
+	// FIXME this can probably turn into a unify_and
 	if (receiver->can_eq (expected, false))
 	  return CoercionResult{{}, expected->clone ()};
 
 	return CoercionResult::get_error ();
       }
     }
 
+  bool receiver_is_non_ptr = receiver->get_kind () != TyTy::TypeKind::POINTER;
+  if (autoderef_flag && receiver_is_non_ptr)
+    {
+      // it is unsafe to autoderef to raw pointers
+      return CoercionResult::get_error ();
+    }
+
   if (!coerceable_mutability (from_mutbl, to_mutbl))
     {
       Location lhs = mappings->lookup_location (receiver->get_ref ());
@@ -192,9 +227,9 @@ TypeCoercionRules::coerce_unsafe_ptr (TyTy::BaseType *receiver,
   TyTy::BaseType *result
     = unify_site_and (receiver->get_ref (), TyTy::TyWithLocation (expected),
 		      TyTy::TyWithLocation (coerced_mutability),
-		      Location () /*unify_locus*/, false /*emit_errors*/,
-		      true /*commit_if_ok*/, true /*infer*/,
-		      true /*cleanup on error*/);
+		      locus /*unify_locus*/, false /*emit_errors*/,
+		      !try_flag /*commit_if_ok*/, true /*infer*/,
+		      try_flag /*cleanup on error*/);
   bool unsafe_ptr_coerceion_ok = result->get_kind () != TyTy::TypeKind::ERROR;
   if (unsafe_ptr_coerceion_ok)
     return CoercionResult{{}, result};
@@ -229,8 +264,12 @@ TypeCoercionRules::coerce_borrowed_pointer (TyTy::BaseType *receiver,
 	// back to a final unity anyway
 	rust_debug ("coerce_borrowed_pointer -- unify");
 	TyTy::BaseType *result
-	  = unify_site (receiver->get_ref (), TyTy::TyWithLocation (receiver),
-			TyTy::TyWithLocation (expected), locus);
+	  = unify_site_and (receiver->get_ref (),
+			    TyTy::TyWithLocation (receiver),
+			    TyTy::TyWithLocation (expected), locus,
+			    false /*emit_errors*/, true /*commit_if_ok*/,
+			    false /* FIXME infer do we want to allow this?? */,
+			    true /*cleanup_on_failure*/);
 	return CoercionResult{{}, result};
       }
     }

gcc/rust/typecheck/rust-coercion.h

@@ -69,7 +69,7 @@ class TypeCoercionRules : protected AutoderefCycle
 
 protected:
   TypeCoercionRules (TyTy::BaseType *expected, Location locus, bool emit_errors,
-		     bool allow_autoderef);
+		     bool allow_autoderef, bool try_flag);
 
   bool select (TyTy::BaseType &autoderefed) override;
 
@@ -87,6 +87,7 @@ class TypeCoercionRules : protected AutoderefCycle
   // mutable fields
   CoercionResult try_result;
   bool emit_errors;
+  bool try_flag;
 };
 
 } // namespace Resolver