gcc/rust/typecheck/rust-hir-dot-operator.cc - gcc - Git at Google

 // Copyright (C) 2020-2023 Free Software Foundation, Inc.

 // This file is part of GCC.

 // GCC is free software; you can redistribute it and/or modify it under
 // the terms of the GNU General Public License as published by the Free
 // Software Foundation; either version 3, or (at your option) any later
 // version.

 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 // for more details.

 // You should have received a copy of the GNU General Public License
 // along with GCC; see the file COPYING3.  If not see
 // <http://www.gnu.org/licenses/>.

 #include "rust-hir-dot-operator.h"
 #include "rust-hir-path-probe.h"
 #include "rust-hir-trait-resolve.h"

 namespace Rust {
 namespace Resolver {

 MethodResolver::MethodResolver (bool autoderef_flag,
 				const HIR::PathIdentSegment &segment_name)
   : AutoderefCycle (autoderef_flag), segment_name (segment_name), result ()
 {}

 std::set<MethodCandidate>
 MethodResolver::Probe (const TyTy::BaseType *receiver,
 		       const HIR::PathIdentSegment &segment_name,
 		       bool autoderef_flag)
 {
   MethodResolver resolver (autoderef_flag, segment_name);
   resolver.cycle (receiver);
   return resolver.result;
 }

 void
 MethodResolver::try_hook (const TyTy::BaseType &r)
 {
   const auto &specified_bounds = r.get_specified_bounds ();
   predicate_items = get_predicate_items (segment_name, r, specified_bounds);
 }

 bool
 MethodResolver::select (const TyTy::BaseType &receiver)
 {
   struct impl_item_candidate
   {
     HIR::Function *item;
     HIR::ImplBlock *impl_block;
     TyTy::FnType *ty;
   };

   // assemble inherent impl items
   std::vector<impl_item_candidate> inherent_impl_fns;
   mappings->iterate_impl_items (
     [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool {
       bool is_trait_impl = impl->has_trait_ref ();
       if (is_trait_impl)
 	return true;

       bool is_fn
 	= item->get_impl_item_type () == HIR::ImplItem::ImplItemType::FUNCTION;
       if (!is_fn)
 	return true;

       HIR::Function *func = static_cast<HIR::Function *> (item);
       if (!func->is_method ())
 	return true;

       bool name_matches
 	= func->get_function_name ().compare (segment_name.as_string ()) == 0;
       if (!name_matches)
 	return true;

       TyTy::BaseType *ty = nullptr;
       if (!query_type (func->get_mappings ().get_hirid (), &ty))
 	return true;
       rust_assert (ty != nullptr);
       if (ty->get_kind () == TyTy::TypeKind::ERROR)
 	return true;

       rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
       TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);

       inherent_impl_fns.push_back ({func, impl, fnty});

       return true;
     });

   struct trait_item_candidate
   {
     const HIR::TraitItemFunc *item;
     const HIR::Trait *trait;
     TyTy::FnType *ty;
     const TraitReference *reference;
     const TraitItemReference *item_ref;
   };

   std::vector<trait_item_candidate> trait_fns;
   mappings->iterate_impl_blocks ([&] (HirId id,
 				      HIR::ImplBlock *impl) mutable -> bool {
     bool is_trait_impl = impl->has_trait_ref ();
     if (!is_trait_impl)
       return true;

     // look for impl implementation else lookup the associated trait item
     for (auto &impl_item : impl->get_impl_items ())
       {
 	bool is_fn = impl_item->get_impl_item_type ()
 		     == HIR::ImplItem::ImplItemType::FUNCTION;
 	if (!is_fn)
 	  continue;

 	HIR::Function *func = static_cast<HIR::Function *> (impl_item.get ());
 	if (!func->is_method ())
 	  continue;

 	bool name_matches
 	  = func->get_function_name ().compare (segment_name.as_string ()) == 0;
 	if (!name_matches)
 	  continue;

 	TyTy::BaseType *ty = nullptr;
 	if (!query_type (func->get_mappings ().get_hirid (), &ty))
 	  continue;
 	if (ty->get_kind () == TyTy::TypeKind::ERROR)
 	  continue;

 	rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
 	TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);

 	inherent_impl_fns.push_back ({func, impl, fnty});
 	return true;
       }

     TraitReference *trait_ref
       = TraitResolver::Resolve (*impl->get_trait_ref ().get ());
     rust_assert (!trait_ref->is_error ());

     auto item_ref
       = trait_ref->lookup_trait_item (segment_name.as_string (),
 				      TraitItemReference::TraitItemType::FN);
     if (item_ref->is_error ())
       return true;

     const HIR::Trait *trait = trait_ref->get_hir_trait_ref ();
     HIR::TraitItem *item = item_ref->get_hir_trait_item ();
     rust_assert (item->get_item_kind () == HIR::TraitItem::TraitItemKind::FUNC);
     HIR::TraitItemFunc *func = static_cast<HIR::TraitItemFunc *> (item);

     TyTy::BaseType *ty = item_ref->get_tyty ();
     rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
     TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);

     trait_item_candidate candidate{func, trait, fnty, trait_ref, item_ref};
     trait_fns.push_back (candidate);

     return true;
   });

   // lookup specified bounds for an associated item
   struct precdicate_candidate
   {
     TyTy::TypeBoundPredicateItem lookup;
     TyTy::FnType *fntype;
   };

   rust_debug ("inherent_impl_fns found {%lu}, trait_fns found {%lu}, "
 	      "predicate_items found {%lu}",
 	      (unsigned long) inherent_impl_fns.size (),
 	      (unsigned long) trait_fns.size (),
 	      (unsigned long) predicate_items.size ());

   // see the follow for the proper fix to get rid of this we need to assemble
   // candidates based on a match expression gathering the relevant impl blocks
   // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L580-L694
   TyTy::set_cmp_autoderef_mode ();

   bool found_possible_candidate = false;
   for (auto &impl_item : inherent_impl_fns)
     {
       bool is_trait_impl_block = impl_item.impl_block->has_trait_ref ();
       if (is_trait_impl_block)
 	continue;

       TyTy::FnType *fn = impl_item.ty;
       rust_assert (fn->is_method ());

       TyTy::BaseType *fn_self = fn->get_self_type ();
       rust_debug ("dot-operator impl_item fn_self={%s} can_eq receiver={%s}",
 		  fn_self->debug_str ().c_str (),
 		  receiver.debug_str ().c_str ());
       if (fn_self->can_eq (&receiver, false))
 	{
 	  PathProbeCandidate::ImplItemCandidate c{impl_item.item,
 						  impl_item.impl_block};
 	  auto try_result = MethodCandidate{
 	    PathProbeCandidate (PathProbeCandidate::CandidateType::IMPL_FUNC,
 				fn, impl_item.item->get_locus (), c),
 	    adjustments};
 	  result.insert (std::move (try_result));
 	  found_possible_candidate = true;
 	}
     }
   if (found_possible_candidate)
     {
       TyTy::reset_cmp_autoderef_mode ();
       return true;
     }

   for (auto &impl_item : inherent_impl_fns)
     {
       bool is_trait_impl_block = impl_item.impl_block->has_trait_ref ();
       if (!is_trait_impl_block)
 	continue;

       TyTy::FnType *fn = impl_item.ty;
       rust_assert (fn->is_method ());

       TyTy::BaseType *fn_self = fn->get_self_type ();
       rust_debug (
 	"dot-operator trait_impl_item fn_self={%s} can_eq receiver={%s}",
 	fn_self->debug_str ().c_str (), receiver.debug_str ().c_str ());
       if (fn_self->can_eq (&receiver, false))
 	{
 	  PathProbeCandidate::ImplItemCandidate c{impl_item.item,
 						  impl_item.impl_block};
 	  auto try_result = MethodCandidate{
 	    PathProbeCandidate (PathProbeCandidate::CandidateType::IMPL_FUNC,
 				fn, impl_item.item->get_locus (), c),
 	    adjustments};
 	  result.insert (std::move (try_result));
 	  found_possible_candidate = true;
 	}
     }
   if (found_possible_candidate)
     {
       TyTy::reset_cmp_autoderef_mode ();
       return true;
     }

   for (auto trait_item : trait_fns)
     {
       TyTy::FnType *fn = trait_item.ty;
       rust_assert (fn->is_method ());

       TyTy::BaseType *fn_self = fn->get_self_type ();
       rust_debug ("dot-operator trait_item fn_self={%s} can_eq receiver={%s}",
 		  fn_self->debug_str ().c_str (),
 		  receiver.debug_str ().c_str ());
       if (fn_self->can_eq (&receiver, false))
 	{
 	  PathProbeCandidate::TraitItemCandidate c{trait_item.reference,
 						   trait_item.item_ref,
 						   nullptr};
 	  auto try_result = MethodCandidate{
 	    PathProbeCandidate (PathProbeCandidate::CandidateType::TRAIT_FUNC,
 				fn, trait_item.item->get_locus (), c),
 	    adjustments};
 	  result.insert (std::move (try_result));
 	  found_possible_candidate = true;
 	}
     }
   if (found_possible_candidate)
     {
       TyTy::reset_cmp_autoderef_mode ();
       return true;
     }

   for (const auto &predicate : predicate_items)
     {
       const TyTy::FnType *fn = predicate.fntype;
       rust_assert (fn->is_method ());

       TyTy::BaseType *fn_self = fn->get_self_type ();
       rust_debug ("dot-operator predicate fn_self={%s} can_eq receiver={%s}",
 		  fn_self->debug_str ().c_str (),
 		  receiver.debug_str ().c_str ());
       if (fn_self->can_eq (&receiver, false))
 	{
 	  const TraitReference *trait_ref
 	    = predicate.lookup.get_parent ()->get ();
 	  const TraitItemReference *trait_item
 	    = predicate.lookup.get_raw_item ();

 	  PathProbeCandidate::TraitItemCandidate c{trait_ref, trait_item,
 						   nullptr};
 	  auto try_result = MethodCandidate{
 	    PathProbeCandidate (PathProbeCandidate::CandidateType::TRAIT_FUNC,
 				fn->clone (), trait_item->get_locus (), c),
 	    adjustments};
 	  result.insert (std::move (try_result));
 	  found_possible_candidate = true;
 	}
     }

   TyTy::reset_cmp_autoderef_mode ();
   return found_possible_candidate;
 }

 std::vector<MethodResolver::predicate_candidate>
 MethodResolver::get_predicate_items (
   const HIR::PathIdentSegment &segment_name, const TyTy::BaseType &receiver,
   const std::vector<TyTy::TypeBoundPredicate> &specified_bounds)
 {
   std::vector<predicate_candidate> predicate_items;
   for (auto &bound : specified_bounds)
     {
       TyTy::TypeBoundPredicateItem lookup
 	= bound.lookup_associated_item (segment_name.as_string ());
       if (lookup.is_error ())
 	continue;

       TyTy::BaseType *ty = lookup.get_tyty_for_receiver (&receiver);
       if (ty->get_kind () == TyTy::TypeKind::FNDEF)
 	{
 	  TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);
 	  predicate_candidate candidate{lookup, fnty};
 	  predicate_items.push_back (candidate);
 	}
     }

   return predicate_items;
 }

 } // namespace Resolver
 } // namespace Rust
	// Copyright (C) 2020-2023 Free Software Foundation, Inc.

	// This file is part of GCC.

	// GCC is free software; you can redistribute it and/or modify it under
	// the terms of the GNU General Public License as published by the Free
	// Software Foundation; either version 3, or (at your option) any later
	// version.

	// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	// WARRANTY; without even the implied warranty of MERCHANTABILITY or
	// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	// for more details.

	// You should have received a copy of the GNU General Public License
	// along with GCC; see the file COPYING3. If not see
	// <http://www.gnu.org/licenses/>.

	#include "rust-hir-dot-operator.h"
	#include "rust-hir-path-probe.h"
	#include "rust-hir-trait-resolve.h"

	namespace Rust {
	namespace Resolver {

	MethodResolver::MethodResolver (bool autoderef_flag,
	const HIR::PathIdentSegment &segment_name)
	: AutoderefCycle (autoderef_flag), segment_name (segment_name), result ()
	{}

	std::set<MethodCandidate>
	MethodResolver::Probe (const TyTy::BaseType *receiver,
	const HIR::PathIdentSegment &segment_name,
	bool autoderef_flag)
	{
	MethodResolver resolver (autoderef_flag, segment_name);
	resolver.cycle (receiver);
	return resolver.result;
	}

	void
	MethodResolver::try_hook (const TyTy::BaseType &r)
	{
	const auto &specified_bounds = r.get_specified_bounds ();
	predicate_items = get_predicate_items (segment_name, r, specified_bounds);
	}

	bool
	MethodResolver::select (const TyTy::BaseType &receiver)
	{
	struct impl_item_candidate
	{
	HIR::Function *item;
	HIR::ImplBlock *impl_block;
	TyTy::FnType *ty;
	};

	// assemble inherent impl items
	std::vector<impl_item_candidate> inherent_impl_fns;
	mappings->iterate_impl_items (
	[&] (HirId id, HIR::ImplItem item, HIR::ImplBlock impl) mutable -> bool {
	bool is_trait_impl = impl->has_trait_ref ();
	if (is_trait_impl)
	return true;

	bool is_fn
	= item->get_impl_item_type () == HIR::ImplItem::ImplItemType::FUNCTION;
	if (!is_fn)
	return true;

	HIR::Function func = static_cast<HIR::Function > (item);
	if (!func->is_method ())
	return true;

	bool name_matches
	= func->get_function_name ().compare (segment_name.as_string ()) == 0;
	if (!name_matches)
	return true;

	TyTy::BaseType *ty = nullptr;
	if (!query_type (func->get_mappings ().get_hirid (), &ty))
	return true;
	rust_assert (ty != nullptr);
	if (ty->get_kind () == TyTy::TypeKind::ERROR)
	return true;

	rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
	TyTy::FnType fnty = static_cast<TyTy::FnType > (ty);

	inherent_impl_fns.push_back ({func, impl, fnty});

	return true;
	});

	struct trait_item_candidate
	{
	const HIR::TraitItemFunc *item;
	const HIR::Trait *trait;
	TyTy::FnType *ty;
	const TraitReference *reference;
	const TraitItemReference *item_ref;
	};

	std::vector<trait_item_candidate> trait_fns;
	mappings->iterate_impl_blocks ([&] (HirId id,
	HIR::ImplBlock *impl) mutable -> bool {
	bool is_trait_impl = impl->has_trait_ref ();
	if (!is_trait_impl)
	return true;

	// look for impl implementation else lookup the associated trait item
	for (auto &impl_item : impl->get_impl_items ())
	{
	bool is_fn = impl_item->get_impl_item_type ()
	== HIR::ImplItem::ImplItemType::FUNCTION;
	if (!is_fn)
	continue;

	HIR::Function func = static_cast<HIR::Function > (impl_item.get ());
	if (!func->is_method ())
	continue;

	bool name_matches
	= func->get_function_name ().compare (segment_name.as_string ()) == 0;
	if (!name_matches)
	continue;

	TyTy::BaseType *ty = nullptr;
	if (!query_type (func->get_mappings ().get_hirid (), &ty))
	continue;
	if (ty->get_kind () == TyTy::TypeKind::ERROR)
	continue;

	rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
	TyTy::FnType fnty = static_cast<TyTy::FnType > (ty);

	inherent_impl_fns.push_back ({func, impl, fnty});
	return true;
	}

	TraitReference *trait_ref
	= TraitResolver::Resolve (*impl->get_trait_ref ().get ());
	rust_assert (!trait_ref->is_error ());

	auto item_ref
	= trait_ref->lookup_trait_item (segment_name.as_string (),
	TraitItemReference::TraitItemType::FN);
	if (item_ref->is_error ())
	return true;

	const HIR::Trait *trait = trait_ref->get_hir_trait_ref ();
	HIR::TraitItem *item = item_ref->get_hir_trait_item ();
	rust_assert (item->get_item_kind () == HIR::TraitItem::TraitItemKind::FUNC);
	HIR::TraitItemFunc func = static_cast<HIR::TraitItemFunc > (item);

	TyTy::BaseType *ty = item_ref->get_tyty ();
	rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
	TyTy::FnType fnty = static_cast<TyTy::FnType > (ty);

	trait_item_candidate candidate{func, trait, fnty, trait_ref, item_ref};
	trait_fns.push_back (candidate);

	return true;
	});

	// lookup specified bounds for an associated item
	struct precdicate_candidate
	{
	TyTy::TypeBoundPredicateItem lookup;
	TyTy::FnType *fntype;
	};

	rust_debug ("inherent_impl_fns found {%lu}, trait_fns found {%lu}, "
	"predicate_items found {%lu}",
	(unsigned long) inherent_impl_fns.size (),
	(unsigned long) trait_fns.size (),
	(unsigned long) predicate_items.size ());

	// see the follow for the proper fix to get rid of this we need to assemble
	// candidates based on a match expression gathering the relevant impl blocks
	// https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L580-L694
	TyTy::set_cmp_autoderef_mode ();

	bool found_possible_candidate = false;
	for (auto &impl_item : inherent_impl_fns)
	{
	bool is_trait_impl_block = impl_item.impl_block->has_trait_ref ();
	if (is_trait_impl_block)
	continue;

	TyTy::FnType *fn = impl_item.ty;
	rust_assert (fn->is_method ());

	TyTy::BaseType *fn_self = fn->get_self_type ();
	rust_debug ("dot-operator impl_item fn_self={%s} can_eq receiver={%s}",
	fn_self->debug_str ().c_str (),
	receiver.debug_str ().c_str ());
	if (fn_self->can_eq (&receiver, false))
	{
	PathProbeCandidate::ImplItemCandidate c{impl_item.item,
	impl_item.impl_block};
	auto try_result = MethodCandidate{
	PathProbeCandidate (PathProbeCandidate::CandidateType::IMPL_FUNC,
	fn, impl_item.item->get_locus (), c),
	adjustments};
	result.insert (std::move (try_result));
	found_possible_candidate = true;
	}
	}
	if (found_possible_candidate)
	{
	TyTy::reset_cmp_autoderef_mode ();
	return true;
	}

	for (auto &impl_item : inherent_impl_fns)
	{
	bool is_trait_impl_block = impl_item.impl_block->has_trait_ref ();
	if (!is_trait_impl_block)
	continue;

	TyTy::FnType *fn = impl_item.ty;
	rust_assert (fn->is_method ());

	TyTy::BaseType *fn_self = fn->get_self_type ();
	rust_debug (
	"dot-operator trait_impl_item fn_self={%s} can_eq receiver={%s}",
	fn_self->debug_str ().c_str (), receiver.debug_str ().c_str ());
	if (fn_self->can_eq (&receiver, false))
	{
	PathProbeCandidate::ImplItemCandidate c{impl_item.item,
	impl_item.impl_block};
	auto try_result = MethodCandidate{
	PathProbeCandidate (PathProbeCandidate::CandidateType::IMPL_FUNC,
	fn, impl_item.item->get_locus (), c),
	adjustments};
	result.insert (std::move (try_result));
	found_possible_candidate = true;
	}
	}
	if (found_possible_candidate)
	{
	TyTy::reset_cmp_autoderef_mode ();
	return true;
	}

	for (auto trait_item : trait_fns)
	{
	TyTy::FnType *fn = trait_item.ty;
	rust_assert (fn->is_method ());

	TyTy::BaseType *fn_self = fn->get_self_type ();
	rust_debug ("dot-operator trait_item fn_self={%s} can_eq receiver={%s}",
	fn_self->debug_str ().c_str (),
	receiver.debug_str ().c_str ());
	if (fn_self->can_eq (&receiver, false))
	{
	PathProbeCandidate::TraitItemCandidate c{trait_item.reference,
	trait_item.item_ref,
	nullptr};
	auto try_result = MethodCandidate{
	PathProbeCandidate (PathProbeCandidate::CandidateType::TRAIT_FUNC,
	fn, trait_item.item->get_locus (), c),
	adjustments};
	result.insert (std::move (try_result));
	found_possible_candidate = true;
	}
	}
	if (found_possible_candidate)
	{
	TyTy::reset_cmp_autoderef_mode ();
	return true;
	}

	for (const auto &predicate : predicate_items)
	{
	const TyTy::FnType *fn = predicate.fntype;
	rust_assert (fn->is_method ());

	TyTy::BaseType *fn_self = fn->get_self_type ();
	rust_debug ("dot-operator predicate fn_self={%s} can_eq receiver={%s}",
	fn_self->debug_str ().c_str (),
	receiver.debug_str ().c_str ());
	if (fn_self->can_eq (&receiver, false))
	{
	const TraitReference *trait_ref
	= predicate.lookup.get_parent ()->get ();
	const TraitItemReference *trait_item
	= predicate.lookup.get_raw_item ();

	PathProbeCandidate::TraitItemCandidate c{trait_ref, trait_item,
	nullptr};
	auto try_result = MethodCandidate{
	PathProbeCandidate (PathProbeCandidate::CandidateType::TRAIT_FUNC,
	fn->clone (), trait_item->get_locus (), c),
	adjustments};
	result.insert (std::move (try_result));
	found_possible_candidate = true;
	}
	}

	TyTy::reset_cmp_autoderef_mode ();
	return found_possible_candidate;
	}

	std::vector<MethodResolver::predicate_candidate>
	MethodResolver::get_predicate_items (
	const HIR::PathIdentSegment &segment_name, const TyTy::BaseType &receiver,
	const std::vector<TyTy::TypeBoundPredicate> &specified_bounds)
	{
	std::vector<predicate_candidate> predicate_items;
	for (auto &bound : specified_bounds)
	{
	TyTy::TypeBoundPredicateItem lookup
	= bound.lookup_associated_item (segment_name.as_string ());
	if (lookup.is_error ())
	continue;

	TyTy::BaseType *ty = lookup.get_tyty_for_receiver (&receiver);
	if (ty->get_kind () == TyTy::TypeKind::FNDEF)
	{
	TyTy::FnType fnty = static_cast<TyTy::FnType > (ty);
	predicate_candidate candidate{lookup, fnty};
	predicate_items.push_back (candidate);
	}
	}

	return predicate_items;
	}

	} // namespace Resolver
	} // namespace Rust