gcc/rust/typecheck/rust-type-util.cc

   1 // Copyright (C) 2020-2025 Free Software Foundation, Inc.
   2
   3 // This file is part of GCC.
   4
   5 // GCC is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 3, or (at your option) any later
   8 // version.
   9
  10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 // for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with GCC; see the file COPYING3.  If not see
  17 // <http://www.gnu.org/licenses/>.
  18
  19 #include "rust-type-util.h"
  20 #include "rust-diagnostics.h"
  21 #include "rust-hir-map.h"
  22 #include "rust-hir-type-check-implitem.h"
  23 #include "rust-hir-type-check-item.h"
  24 #include "rust-hir-type-check.h"
  25 #include "rust-casts.h"
  26 #include "rust-unify.h"
  27 #include "rust-coercion.h"
  28 #include "rust-hir-type-bounds.h"
  29
  30 namespace Rust {
  31 namespace Resolver {
  32
  33 bool
  34 query_type (HirId reference, TyTy::BaseType **result)
  35 {
  36   Analysis::Mappings *mappings = Analysis::Mappings::get ();
  37   TypeCheckContext *context = TypeCheckContext::get ();
  38
  39   if (context->query_in_progress (reference))
  40     return false;
  41
  42   if (context->lookup_type (reference, result))
  43     return true;
  44
  45   context->insert_query (reference);
  46
  47   std::pair<HIR::Enum *, HIR::EnumItem *> enum_candidiate
  48     = mappings->lookup_hir_enumitem (reference);
  49   bool enum_candidiate_ok
  50     = enum_candidiate.first != nullptr && enum_candidiate.second != nullptr;
  51   if (enum_candidiate_ok)
  52     {
  53       HIR::Enum *parent = enum_candidiate.first;
  54       HIR::EnumItem *enum_item = enum_candidiate.second;
  55       rust_debug_loc (enum_item->get_locus (), "resolved item {%u} to",
  56                       reference);
  57
  58       *result = TypeCheckItem::Resolve (*parent);
  59
  60       context->query_completed (reference);
  61       return true;
  62     }
  63
  64   HIR::Item *item = mappings->lookup_hir_item (reference);
  65   if (item != nullptr)
  66     {
  67       rust_debug_loc (item->get_locus (), "resolved item {%u} to", reference);
  68       *result = TypeCheckItem::Resolve (*item);
  69       context->query_completed (reference);
  70       return true;
  71     }
  72
  73   HirId parent_impl_id = UNKNOWN_HIRID;
  74   HIR::ImplItem *impl_item
  75     = mappings->lookup_hir_implitem (reference, &parent_impl_id);
  76   if (impl_item != nullptr)
  77     {
  78       HIR::ImplBlock *impl_block
  79         = mappings->lookup_hir_impl_block (parent_impl_id);
  80       rust_assert (impl_block != nullptr);
  81
  82       // found an impl item
  83       rust_debug_loc (impl_item->get_locus (), "resolved impl-item {%u} to",
  84                       reference);
  85
  86       *result = TypeCheckItem::ResolveImplItem (*impl_block, *impl_item);
  87       context->query_completed (reference);
  88       return true;
  89     }
  90
  91   // is it an impl_type?
  92   HIR::ImplBlock *impl_block_by_type = nullptr;
  93   bool found_impl_block_type
  94     = mappings->lookup_impl_block_type (reference, &impl_block_by_type);
  95   if (found_impl_block_type)
  96     {
  97       *result = TypeCheckItem::ResolveImplBlockSelf (*impl_block_by_type);
  98       context->query_completed (reference);
  99       return true;
 100     }
 101
 102   // is it an extern item?
 103   HirId parent_extern_block_id = UNKNOWN_HIRID;
 104   HIR::ExternalItem *extern_item
 105     = mappings->lookup_hir_extern_item (reference, &parent_extern_block_id);
 106   if (extern_item != nullptr)
 107     {
 108       HIR::ExternBlock *block
 109         = mappings->lookup_hir_extern_block (parent_extern_block_id);
 110       rust_assert (block != nullptr);
 111
 112       *result = TypeCheckTopLevelExternItem::Resolve (extern_item, *block);
 113       context->query_completed (reference);
 114       return true;
 115     }
 116
 117   // more?
 118   location_t possible_locus = mappings->lookup_location (reference);
 119   rust_debug_loc (possible_locus, "query system failed to resolve: [%u]",
 120                   reference);
 121   context->query_completed (reference);
 122
 123   return false;
 124 }
 125
 126 bool
 127 types_compatable (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
 128                   location_t unify_locus, bool emit_errors)
 129 {
 130   TyTy::BaseType *result
 131     = unify_site_and (UNKNOWN_HIRID, lhs, rhs, unify_locus, emit_errors,
 132                       false /*commit*/, true /*infer*/, true /*cleanup*/);
 133   return result->get_kind () != TyTy::TypeKind::ERROR;
 134 }
 135
 136 TyTy::BaseType *
 137 unify_site (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
 138             location_t unify_locus)
 139 {
 140   TyTy::BaseType *expected = lhs.get_ty ();
 141   TyTy::BaseType *expr = rhs.get_ty ();
 142
 143   rust_debug ("unify_site id={%u} expected={%s} expr={%s}", id,
 144               expected->debug_str ().c_str (), expr->debug_str ().c_str ());
 145
 146   std::vector<UnifyRules::CommitSite> commits;
 147   std::vector<UnifyRules::InferenceSite> infers;
 148   return UnifyRules::Resolve (lhs, rhs, unify_locus, true /*commit*/,
 149                               true /*emit_error*/, false /*infer*/, commits,
 150                               infers);
 151 }
 152
 153 TyTy::BaseType *
 154 unify_site_and (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
 155                 location_t unify_locus, bool emit_errors, bool commit_if_ok,
 156                 bool implicit_infer_vars, bool cleanup)
 157 {
 158   TypeCheckContext &context = *TypeCheckContext::get ();
 159
 160   TyTy::BaseType *expected = lhs.get_ty ();
 161   TyTy::BaseType *expr = rhs.get_ty ();
 162
 163   rust_debug (
 164     "unify_site_and commit %s infer %s id={%u} expected={%s} expr={%s}",
 165     commit_if_ok ? "true" : "false", implicit_infer_vars ? "true" : "false", id,
 166     expected->debug_str ().c_str (), expr->debug_str ().c_str ());
 167
 168   std::vector<UnifyRules::CommitSite> commits;
 169   std::vector<UnifyRules::InferenceSite> infers;
 170   TyTy::BaseType *result
 171     = UnifyRules::Resolve (lhs, rhs, unify_locus, false /*commit inline*/,
 172                            emit_errors, implicit_infer_vars, commits, infers);
 173   bool ok = result->get_kind () != TyTy::TypeKind::ERROR;
 174   if (ok && commit_if_ok)
 175     {
 176       for (auto &c : commits)
 177         {
 178           UnifyRules::commit (c.lhs, c.rhs, c.resolved);
 179         }
 180     }
 181   else if (cleanup)
 182     {
 183       // FIXME
 184       // reset the get_next_hir_id
 185
 186       for (auto &i : infers)
 187         {
 188           i.param->set_ref (i.pref);
 189           i.param->set_ty_ref (i.ptyref);
 190
 191           // remove the inference variable
 192           context.clear_type (i.infer);
 193           delete i.infer;
 194         }
 195     }
 196   return result;
 197 }
 198
 199 TyTy::BaseType *
 200 coercion_site (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
 201                location_t locus)
 202 {
 203   TyTy::BaseType *expected = lhs.get_ty ();
 204   TyTy::BaseType *expr = rhs.get_ty ();
 205
 206   rust_debug ("coercion_site id={%u} expected={%s} expr={%s}", id,
 207               expected->debug_str ().c_str (), expr->debug_str ().c_str ());
 208
 209   auto context = TypeCheckContext::get ();
 210   if (expected->get_kind () == TyTy::TypeKind::ERROR
 211       || expr->get_kind () == TyTy::TypeKind::ERROR)
 212     return expr;
 213
 214   // can we autoderef it?
 215   auto result = TypeCoercionRules::Coerce (expr, expected, locus,
 216                                            true /*allow-autodref*/);
 217
 218   // the result needs to be unified
 219   TyTy::BaseType *receiver = expr;
 220   if (!result.is_error ())
 221     {
 222       receiver = result.tyty;
 223     }
 224
 225   rust_debug ("coerce_default_unify(a={%s}, b={%s})",
 226               receiver->debug_str ().c_str (), expected->debug_str ().c_str ());
 227   TyTy::BaseType *coerced
 228     = unify_site (id, lhs, TyTy::TyWithLocation (receiver, rhs.get_locus ()),
 229                   locus);
 230   context->insert_autoderef_mappings (id, std::move (result.adjustments));
 231   return coerced;
 232 }
 233
 234 TyTy::BaseType *
 235 try_coercion (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
 236               location_t locus)
 237 {
 238   TyTy::BaseType *expected = lhs.get_ty ();
 239   TyTy::BaseType *expr = rhs.get_ty ();
 240
 241   rust_debug ("try_coercion_site id={%u} expected={%s} expr={%s}", id,
 242               expected->debug_str ().c_str (), expr->debug_str ().c_str ());
 243
 244   auto result = TypeCoercionRules::TryCoerce (expr, expected, locus,
 245                                               true /*allow-autodref*/);
 246   if (result.is_error ())
 247     return new TyTy::ErrorType (id);
 248
 249   return result.tyty;
 250 }
 251
 252 TyTy::BaseType *
 253 cast_site (HirId id, TyTy::TyWithLocation from, TyTy::TyWithLocation to,
 254            location_t cast_locus)
 255 {
 256   rust_debug ("cast_site id={%u} from={%s} to={%s}", id,
 257               from.get_ty ()->debug_str ().c_str (),
 258               to.get_ty ()->debug_str ().c_str ());
 259
 260   auto context = TypeCheckContext::get ();
 261   if (from.get_ty ()->get_kind () == TyTy::TypeKind::ERROR
 262       || to.get_ty ()->get_kind () == TyTy::TypeKind::ERROR)
 263     return to.get_ty ();
 264
 265   // do the cast
 266   auto result = TypeCastRules::resolve (cast_locus, from, to);
 267
 268   // we assume error has already been emitted
 269   if (result.is_error ())
 270     return to.get_ty ();
 271
 272   // the result needs to be unified
 273   TyTy::BaseType *casted_result = result.tyty;
 274   rust_debug ("cast_default_unify(a={%s}, b={%s})",
 275               casted_result->debug_str ().c_str (),
 276               to.get_ty ()->debug_str ().c_str ());
 277
 278   TyTy::BaseType *casted
 279     = unify_site (id, to,
 280                   TyTy::TyWithLocation (casted_result, from.get_locus ()),
 281                   cast_locus);
 282   context->insert_cast_autoderef_mappings (id, std::move (result.adjustments));
 283   return casted;
 284 }
 285
 286 AssociatedImplTrait *
 287 lookup_associated_impl_block (const TyTy::TypeBoundPredicate &bound,
 288                               const TyTy::BaseType *binding, bool *ambigious)
 289 {
 290   auto context = TypeCheckContext::get ();
 291
 292   // setup any associated type mappings for the specified bonds and this
 293   // type
 294   auto candidates = TypeBoundsProbe::Probe (binding);
 295   std::vector<AssociatedImplTrait *> associated_impl_traits;
 296   for (auto &probed_bound : candidates)
 297     {
 298       HIR::ImplBlock *associated_impl = probed_bound.second;
 299
 300       HirId impl_block_id = associated_impl->get_mappings ().get_hirid ();
 301       AssociatedImplTrait *associated = nullptr;
 302       bool found_impl_trait
 303         = context->lookup_associated_trait_impl (impl_block_id, &associated);
 304       if (found_impl_trait)
 305         {
 306           // compare the bounds from here i think is what we can do:
 307           if (bound.is_equal (associated->get_predicate ()))
 308             {
 309               associated_impl_traits.push_back (associated);
 310             }
 311         }
 312     }
 313
 314   if (associated_impl_traits.empty ())
 315     return nullptr;
 316
 317   // This code is important when you look at slices for example when
 318   // you have a slice such as:
 319   //
 320   // let slice = &array[1..3]
 321   //
 322   // the higher ranked bounds will end up having an Index trait
 323   // implementation for Range<usize> so we need this code to resolve
 324   // that we have an integer inference variable that needs to become
 325   // a usize
 326   //
 327   // The other complicated issue is that we might have an intrinsic
 328   // which requires the :Clone or Copy bound but the libcore adds
 329   // implementations for all the integral types so when there are
 330   // multiple candidates we need to resolve to the default
 331   // implementation for that type otherwise its an error for
 332   // ambiguous type bounds
 333
 334   // if we have a non-general inference variable we need to be
 335   // careful about the selection here
 336   bool is_infer_var = binding->get_kind () == TyTy::TypeKind::INFER;
 337   bool is_integer_infervar
 338     = is_infer_var
 339       && static_cast<const TyTy::InferType *> (binding)->get_infer_kind ()
 340            == TyTy::InferType::InferTypeKind::INTEGRAL;
 341   bool is_float_infervar
 342     = is_infer_var
 343       && static_cast<const TyTy::InferType *> (binding)->get_infer_kind ()
 344            == TyTy::InferType::InferTypeKind::FLOAT;
 345
 346   AssociatedImplTrait *associate_impl_trait = nullptr;
 347   if (associated_impl_traits.size () == 1)
 348     {
 349       // just go for it
 350       associate_impl_trait = associated_impl_traits.at (0);
 351     }
 352   else if (is_integer_infervar)
 353     {
 354       TyTy::BaseType *type = nullptr;
 355       bool ok = context->lookup_builtin ("i32", &type);
 356       rust_assert (ok);
 357
 358       for (auto &impl : associated_impl_traits)
 359         {
 360           bool found = impl->get_self ()->is_equal (*type);
 361           if (found)
 362             {
 363               associate_impl_trait = impl;
 364               break;
 365             }
 366         }
 367     }
 368   else if (is_float_infervar)
 369     {
 370       TyTy::BaseType *type = nullptr;
 371       bool ok = context->lookup_builtin ("f64", &type);
 372       rust_assert (ok);
 373
 374       for (auto &impl : associated_impl_traits)
 375         {
 376           bool found = impl->get_self ()->is_equal (*type);
 377           if (found)
 378             {
 379               associate_impl_trait = impl;
 380               break;
 381             }
 382         }
 383     }
 384
 385   if (associate_impl_trait == nullptr && ambigious != nullptr)
 386     {
 387       *ambigious = true;
 388     }
 389
 390   return associate_impl_trait;
 391 }
 392
 393 } // namespace Resolver
 394 } // namespace Rust