gcc/rust/backend/rust-compile-resolve-path.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-compile-resolve-path.h"
 #include "rust-compile-intrinsic.h"
 #include "rust-compile-item.h"
 #include "rust-compile-implitem.h"
 #include "rust-compile-expr.h"
 #include "rust-hir-trait-resolve.h"
 #include "rust-hir-path-probe.h"
 #include "rust-compile-extern.h"
 #include "rust-constexpr.h"

 namespace Rust {
 namespace Compile {

 void
 ResolvePathRef::visit (HIR::QualifiedPathInExpression &expr)
 {
   resolved = resolve (expr.get_final_segment ().get_segment (),
 		      expr.get_mappings (), expr.get_locus (), true);
 }

 void
 ResolvePathRef::visit (HIR::PathInExpression &expr)
 {
   resolved = resolve (expr.get_final_segment ().get_segment (),
 		      expr.get_mappings (), expr.get_locus (), false);
 }

 tree
 ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
 			 const Analysis::NodeMapping &mappings,
 			 Location expr_locus, bool is_qualified_path)
 {
   TyTy::BaseType *lookup = nullptr;
   bool ok = ctx->get_tyctx ()->lookup_type (mappings.get_hirid (), &lookup);
   rust_assert (ok);

   // need to look up the reference for this identifier
   NodeId ref_node_id = UNKNOWN_NODEID;
   if (!ctx->get_resolver ()->lookup_resolved_name (mappings.get_nodeid (),
 						   &ref_node_id))
     {
       // this can fail because it might be a Constructor for something
       // in that case the caller should attempt ResolvePathType::Compile

       // it might be an enum data-less enum variant
       if (lookup->get_kind () != TyTy::TypeKind::ADT)
 	return error_mark_node;

       TyTy::ADTType *adt = static_cast<TyTy::ADTType *> (lookup);

       // it might be a unit-struct
       if (adt->is_unit ())
 	{
 	  return ctx->get_backend ()->unit_expression ();
 	}

       if (!adt->is_enum ())
 	return error_mark_node;

       HirId variant_id;
       if (!ctx->get_tyctx ()->lookup_variant_definition (mappings.get_hirid (),
 							 &variant_id))
 	return error_mark_node;

       int union_disriminator = -1;
       TyTy::VariantDef *variant = nullptr;
       if (!adt->lookup_variant_by_id (variant_id, &variant,
 				      &union_disriminator))
 	return error_mark_node;

       // this can only be for discriminant variants the others are built up
       // using call-expr or struct-init
       rust_assert (variant->get_variant_type ()
 		   == TyTy::VariantDef::VariantType::NUM);

       // we need the actual gcc type
       tree compiled_adt_type = TyTyResolveCompile::compile (ctx, adt);

       // make the ctor for the union
       HIR::Expr *discrim_expr = variant->get_discriminant ();
       tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
       tree folded_discrim_expr = fold_expr (discrim_expr_node);
       tree qualifier = folded_discrim_expr;

       return ctx->get_backend ()->constructor_expression (compiled_adt_type,
 							  true, {qualifier},
 							  union_disriminator,
 							  expr_locus);
     }

   HirId ref;
   if (!ctx->get_mappings ()->lookup_node_to_hir (ref_node_id, &ref))
     {
       rust_error_at (expr_locus, "reverse call path lookup failure");
       return error_mark_node;
     }

   // might be a constant
   tree constant_expr;
   if (ctx->lookup_const_decl (ref, &constant_expr))
     {
       TREE_USED (constant_expr) = 1;
       return constant_expr;
     }

   // maybe closure binding
   tree closure_binding = error_mark_node;
   if (ctx->lookup_closure_binding (ref, &closure_binding))
     {
       TREE_USED (closure_binding) = 1;
       return closure_binding;
     }

   // this might be a variable reference or a function reference
   Bvariable *var = nullptr;
   if (ctx->lookup_var_decl (ref, &var))
     {
       // TREE_USED is setup in the gcc abstraction here
       return ctx->get_backend ()->var_expression (var, expr_locus);
     }

   // might be a match pattern binding
   tree binding = error_mark_node;
   if (ctx->lookup_pattern_binding (ref, &binding))
     {
       TREE_USED (binding) = 1;
       return binding;
     }

   // it might be a function call
   if (lookup->get_kind () == TyTy::TypeKind::FNDEF)
     {
       TyTy::FnType *fntype = static_cast<TyTy::FnType *> (lookup);
       tree fn = NULL_TREE;
       if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
 	{
 	  TREE_USED (fn) = 1;
 	  return address_expression (fn, expr_locus);
 	}
       else if (fntype->get_abi () == ABI::INTRINSIC)
 	{
 	  Intrinsics compile (ctx);
 	  fn = compile.compile (fntype);
 	  TREE_USED (fn) = 1;
 	  return address_expression (fn, expr_locus);
 	}
     }

   // let the query system figure it out
   tree resolved_item = query_compile (ref, lookup, final_segment, mappings,
 				      expr_locus, is_qualified_path);
   if (resolved_item != error_mark_node)
     {
       TREE_USED (resolved_item) = 1;
     }
   return resolved_item;
 }

 tree
 HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
 			       const HIR::PathIdentSegment &final_segment,
 			       const Analysis::NodeMapping &mappings,
 			       Location expr_locus, bool is_qualified_path)
 {
   HIR::Item *resolved_item = ctx->get_mappings ()->lookup_hir_item (ref);
   HirId parent_block;
   HIR::ExternalItem *resolved_extern_item
     = ctx->get_mappings ()->lookup_hir_extern_item (ref, &parent_block);
   bool is_hir_item = resolved_item != nullptr;
   bool is_hir_extern_item = resolved_extern_item != nullptr;
   if (is_hir_item)
     {
       if (!lookup->has_subsititions_defined ())
 	return CompileItem::compile (resolved_item, ctx, nullptr, true,
 				     expr_locus);
       else
 	return CompileItem::compile (resolved_item, ctx, lookup, true,
 				     expr_locus);
     }
   else if (is_hir_extern_item)
     {
       if (!lookup->has_subsititions_defined ())
 	return CompileExternItem::compile (resolved_extern_item, ctx, nullptr,
 					   true, expr_locus);
       else
 	return CompileExternItem::compile (resolved_extern_item, ctx, lookup,
 					   true, expr_locus);
     }
   else
     {
       HirId parent_impl_id = UNKNOWN_HIRID;
       HIR::ImplItem *resolved_item
 	= ctx->get_mappings ()->lookup_hir_implitem (ref, &parent_impl_id);
       bool is_impl_item = resolved_item != nullptr;
       if (is_impl_item)
 	{
 	  rust_assert (parent_impl_id != UNKNOWN_HIRID);
 	  HIR::Item *impl_ref
 	    = ctx->get_mappings ()->lookup_hir_item (parent_impl_id);
 	  rust_assert (impl_ref != nullptr);
 	  HIR::ImplBlock *impl = static_cast<HIR::ImplBlock *> (impl_ref);

 	  TyTy::BaseType *self = nullptr;
 	  bool ok = ctx->get_tyctx ()->lookup_type (
 	    impl->get_type ()->get_mappings ().get_hirid (), &self);
 	  rust_assert (ok);

 	  if (!lookup->has_subsititions_defined ())
 	    return CompileInherentImplItem::Compile (resolved_item, ctx,
 						     nullptr, true, expr_locus);
 	  else
 	    return CompileInherentImplItem::Compile (resolved_item, ctx, lookup,
 						     true, expr_locus);
 	}
       else
 	{
 	  // it might be resolved to a trait item
 	  HIR::TraitItem *trait_item
 	    = ctx->get_mappings ()->lookup_hir_trait_item (ref);
 	  HIR::Trait *trait = ctx->get_mappings ()->lookup_trait_item_mapping (
 	    trait_item->get_mappings ().get_hirid ());

 	  Resolver::TraitReference *trait_ref
 	    = &Resolver::TraitReference::error_node ();
 	  bool ok = ctx->get_tyctx ()->lookup_trait_reference (
 	    trait->get_mappings ().get_defid (), &trait_ref);
 	  rust_assert (ok);

 	  TyTy::BaseType *receiver = nullptr;
 	  ok = ctx->get_tyctx ()->lookup_receiver (mappings.get_hirid (),
 						   &receiver);
 	  rust_assert (ok);

 	  if (receiver->get_kind () == TyTy::TypeKind::PARAM)
 	    {
 	      TyTy::ParamType *p = static_cast<TyTy::ParamType *> (receiver);
 	      receiver = p->resolve ();
 	    }

 	  // the type resolver can only resolve type bounds to their trait
 	  // item so its up to us to figure out if this path should resolve
 	  // to an trait-impl-block-item or if it can be defaulted to the
 	  // trait-impl-item's definition
 	  auto candidates
 	    = Resolver::PathProbeImplTrait::Probe (receiver, final_segment,
 						   trait_ref);
 	  if (candidates.size () == 0)
 	    {
 	      // this means we are defaulting back to the trait_item if
 	      // possible
 	      Resolver::TraitItemReference *trait_item_ref = nullptr;
 	      bool ok = trait_ref->lookup_hir_trait_item (*trait_item,
 							  &trait_item_ref);
 	      rust_assert (ok);				    // found
 	      rust_assert (trait_item_ref->is_optional ()); // has definition

 	      return CompileTraitItem::Compile (
 		trait_item_ref->get_hir_trait_item (), ctx, lookup, true,
 		expr_locus);
 	    }
 	  else
 	    {
 	      rust_assert (candidates.size () == 1);

 	      auto candidate = *candidates.begin ();
 	      rust_assert (candidate.is_impl_candidate ());

 	      HIR::ImplBlock *impl = candidate.item.impl.parent;
 	      HIR::ImplItem *impl_item = candidate.item.impl.impl_item;

 	      TyTy::BaseType *self = nullptr;
 	      bool ok = ctx->get_tyctx ()->lookup_type (
 		impl->get_type ()->get_mappings ().get_hirid (), &self);
 	      rust_assert (ok);

 	      if (!lookup->has_subsititions_defined ())
 		return CompileInherentImplItem::Compile (impl_item, ctx,
 							 nullptr, true,
 							 expr_locus);
 	      else
 		return CompileInherentImplItem::Compile (impl_item, ctx, lookup,
 							 true, expr_locus);
 	    }
 	}
     }

   return error_mark_node;
 }

 } // namespace Compile
 } // 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-compile-resolve-path.h"
	#include "rust-compile-intrinsic.h"
	#include "rust-compile-item.h"
	#include "rust-compile-implitem.h"
	#include "rust-compile-expr.h"
	#include "rust-hir-trait-resolve.h"
	#include "rust-hir-path-probe.h"
	#include "rust-compile-extern.h"
	#include "rust-constexpr.h"

	namespace Rust {
	namespace Compile {

	void
	ResolvePathRef::visit (HIR::QualifiedPathInExpression &expr)
	{
	resolved = resolve (expr.get_final_segment ().get_segment (),
	expr.get_mappings (), expr.get_locus (), true);
	}

	void
	ResolvePathRef::visit (HIR::PathInExpression &expr)
	{
	resolved = resolve (expr.get_final_segment ().get_segment (),
	expr.get_mappings (), expr.get_locus (), false);
	}

	tree
	ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
	const Analysis::NodeMapping &mappings,
	Location expr_locus, bool is_qualified_path)
	{
	TyTy::BaseType *lookup = nullptr;
	bool ok = ctx->get_tyctx ()->lookup_type (mappings.get_hirid (), &lookup);
	rust_assert (ok);

	// need to look up the reference for this identifier
	NodeId ref_node_id = UNKNOWN_NODEID;
	if (!ctx->get_resolver ()->lookup_resolved_name (mappings.get_nodeid (),
	&ref_node_id))
	{
	// this can fail because it might be a Constructor for something
	// in that case the caller should attempt ResolvePathType::Compile

	// it might be an enum data-less enum variant
	if (lookup->get_kind () != TyTy::TypeKind::ADT)
	return error_mark_node;

	TyTy::ADTType adt = static_cast<TyTy::ADTType > (lookup);

	// it might be a unit-struct
	if (adt->is_unit ())
	{
	return ctx->get_backend ()->unit_expression ();
	}

	if (!adt->is_enum ())
	return error_mark_node;

	HirId variant_id;
	if (!ctx->get_tyctx ()->lookup_variant_definition (mappings.get_hirid (),
	&variant_id))
	return error_mark_node;

	int union_disriminator = -1;
	TyTy::VariantDef *variant = nullptr;
	if (!adt->lookup_variant_by_id (variant_id, &variant,
	&union_disriminator))
	return error_mark_node;

	// this can only be for discriminant variants the others are built up
	// using call-expr or struct-init
	rust_assert (variant->get_variant_type ()
	== TyTy::VariantDef::VariantType::NUM);

	// we need the actual gcc type
	tree compiled_adt_type = TyTyResolveCompile::compile (ctx, adt);

	// make the ctor for the union
	HIR::Expr *discrim_expr = variant->get_discriminant ();
	tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
	tree folded_discrim_expr = fold_expr (discrim_expr_node);
	tree qualifier = folded_discrim_expr;

	return ctx->get_backend ()->constructor_expression (compiled_adt_type,
	true, {qualifier},
	union_disriminator,
	expr_locus);
	}

	HirId ref;
	if (!ctx->get_mappings ()->lookup_node_to_hir (ref_node_id, &ref))
	{
	rust_error_at (expr_locus, "reverse call path lookup failure");
	return error_mark_node;
	}

	// might be a constant
	tree constant_expr;
	if (ctx->lookup_const_decl (ref, &constant_expr))
	{
	TREE_USED (constant_expr) = 1;
	return constant_expr;
	}

	// maybe closure binding
	tree closure_binding = error_mark_node;
	if (ctx->lookup_closure_binding (ref, &closure_binding))
	{
	TREE_USED (closure_binding) = 1;
	return closure_binding;
	}

	// this might be a variable reference or a function reference
	Bvariable *var = nullptr;
	if (ctx->lookup_var_decl (ref, &var))
	{
	// TREE_USED is setup in the gcc abstraction here
	return ctx->get_backend ()->var_expression (var, expr_locus);
	}

	// might be a match pattern binding
	tree binding = error_mark_node;
	if (ctx->lookup_pattern_binding (ref, &binding))
	{
	TREE_USED (binding) = 1;
	return binding;
	}

	// it might be a function call
	if (lookup->get_kind () == TyTy::TypeKind::FNDEF)
	{
	TyTy::FnType fntype = static_cast<TyTy::FnType > (lookup);
	tree fn = NULL_TREE;
	if (ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
	{
	TREE_USED (fn) = 1;
	return address_expression (fn, expr_locus);
	}
	else if (fntype->get_abi () == ABI::INTRINSIC)
	{
	Intrinsics compile (ctx);
	fn = compile.compile (fntype);
	TREE_USED (fn) = 1;
	return address_expression (fn, expr_locus);
	}
	}

	// let the query system figure it out
	tree resolved_item = query_compile (ref, lookup, final_segment, mappings,
	expr_locus, is_qualified_path);
	if (resolved_item != error_mark_node)
	{
	TREE_USED (resolved_item) = 1;
	}
	return resolved_item;
	}

	tree
	HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
	const HIR::PathIdentSegment &final_segment,
	const Analysis::NodeMapping &mappings,
	Location expr_locus, bool is_qualified_path)
	{
	HIR::Item *resolved_item = ctx->get_mappings ()->lookup_hir_item (ref);
	HirId parent_block;
	HIR::ExternalItem *resolved_extern_item
	= ctx->get_mappings ()->lookup_hir_extern_item (ref, &parent_block);
	bool is_hir_item = resolved_item != nullptr;
	bool is_hir_extern_item = resolved_extern_item != nullptr;
	if (is_hir_item)
	{
	if (!lookup->has_subsititions_defined ())
	return CompileItem::compile (resolved_item, ctx, nullptr, true,
	expr_locus);
	else
	return CompileItem::compile (resolved_item, ctx, lookup, true,
	expr_locus);
	}
	else if (is_hir_extern_item)
	{
	if (!lookup->has_subsititions_defined ())
	return CompileExternItem::compile (resolved_extern_item, ctx, nullptr,
	true, expr_locus);
	else
	return CompileExternItem::compile (resolved_extern_item, ctx, lookup,
	true, expr_locus);
	}
	else
	{
	HirId parent_impl_id = UNKNOWN_HIRID;
	HIR::ImplItem *resolved_item
	= ctx->get_mappings ()->lookup_hir_implitem (ref, &parent_impl_id);
	bool is_impl_item = resolved_item != nullptr;
	if (is_impl_item)
	{
	rust_assert (parent_impl_id != UNKNOWN_HIRID);
	HIR::Item *impl_ref
	= ctx->get_mappings ()->lookup_hir_item (parent_impl_id);
	rust_assert (impl_ref != nullptr);
	HIR::ImplBlock impl = static_cast<HIR::ImplBlock > (impl_ref);

	TyTy::BaseType *self = nullptr;
	bool ok = ctx->get_tyctx ()->lookup_type (
	impl->get_type ()->get_mappings ().get_hirid (), &self);
	rust_assert (ok);

	if (!lookup->has_subsititions_defined ())
	return CompileInherentImplItem::Compile (resolved_item, ctx,
	nullptr, true, expr_locus);
	else
	return CompileInherentImplItem::Compile (resolved_item, ctx, lookup,
	true, expr_locus);
	}
	else
	{
	// it might be resolved to a trait item
	HIR::TraitItem *trait_item
	= ctx->get_mappings ()->lookup_hir_trait_item (ref);
	HIR::Trait *trait = ctx->get_mappings ()->lookup_trait_item_mapping (
	trait_item->get_mappings ().get_hirid ());

	Resolver::TraitReference *trait_ref
	= &Resolver::TraitReference::error_node ();
	bool ok = ctx->get_tyctx ()->lookup_trait_reference (
	trait->get_mappings ().get_defid (), &trait_ref);
	rust_assert (ok);

	TyTy::BaseType *receiver = nullptr;
	ok = ctx->get_tyctx ()->lookup_receiver (mappings.get_hirid (),
	&receiver);
	rust_assert (ok);

	if (receiver->get_kind () == TyTy::TypeKind::PARAM)
	{
	TyTy::ParamType p = static_cast<TyTy::ParamType > (receiver);
	receiver = p->resolve ();
	}

	// the type resolver can only resolve type bounds to their trait
	// item so its up to us to figure out if this path should resolve
	// to an trait-impl-block-item or if it can be defaulted to the
	// trait-impl-item's definition
	auto candidates
	= Resolver::PathProbeImplTrait::Probe (receiver, final_segment,
	trait_ref);
	if (candidates.size () == 0)
	{
	// this means we are defaulting back to the trait_item if
	// possible
	Resolver::TraitItemReference *trait_item_ref = nullptr;
	bool ok = trait_ref->lookup_hir_trait_item (*trait_item,
	&trait_item_ref);
	rust_assert (ok); // found
	rust_assert (trait_item_ref->is_optional ()); // has definition

	return CompileTraitItem::Compile (
	trait_item_ref->get_hir_trait_item (), ctx, lookup, true,
	expr_locus);
	}
	else
	{
	rust_assert (candidates.size () == 1);

	auto candidate = *candidates.begin ();
	rust_assert (candidate.is_impl_candidate ());

	HIR::ImplBlock *impl = candidate.item.impl.parent;
	HIR::ImplItem *impl_item = candidate.item.impl.impl_item;

	TyTy::BaseType *self = nullptr;
	bool ok = ctx->get_tyctx ()->lookup_type (
	impl->get_type ()->get_mappings ().get_hirid (), &self);
	rust_assert (ok);

	if (!lookup->has_subsititions_defined ())
	return CompileInherentImplItem::Compile (impl_item, ctx,
	nullptr, true,
	expr_locus);
	else
	return CompileInherentImplItem::Compile (impl_item, ctx, lookup,
	true, expr_locus);
	}
	}
	}

	return error_mark_node;
	}

	} // namespace Compile
	} // namespace Rust