gcc/rust/typecheck/rust-hir-trait-reference.cc

   1 // Copyright (C) 2020-2023 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-hir-trait-reference.h"
  20
  21 namespace Rust {
  22 namespace Resolver {
  23
  24 std::string
  25 TraitItemReference::as_string () const
  26 {
  27   return "(" + trait_item_type_as_string (type) + " " + identifier + " " + ")";
  28 }
  29
  30 bool
  31 TraitItemReference::is_error () const
  32 {
  33   return type == ERROR;
  34 }
  35
  36 bool
  37 TraitItemReference::is_optional () const
  38 {
  39   return optional_flag;
  40 };
  41
  42 std::string
  43 TraitItemReference::get_identifier () const
  44 {
  45   return identifier;
  46 }
  47
  48 TraitItemReference::TraitItemType
  49 TraitItemReference::get_trait_item_type () const
  50 {
  51   return type;
  52 }
  53
  54 HIR::TraitItem *
  55 TraitItemReference::get_hir_trait_item () const
  56 {
  57   return hir_trait_item;
  58 }
  59
  60 Location
  61 TraitItemReference::get_locus () const
  62 {
  63   return locus;
  64 }
  65
  66 const Analysis::NodeMapping
  67 TraitItemReference::get_mappings () const
  68 {
  69   return hir_trait_item->get_mappings ();
  70 }
  71
  72 TyTy::BaseType *
  73 TraitItemReference::get_tyty () const
  74 {
  75   rust_assert (hir_trait_item != nullptr);
  76
  77   switch (type)
  78     {
  79     case CONST:
  80       return get_type_from_constant (
  81         static_cast</*const*/ HIR::TraitItemConst &> (*hir_trait_item));
  82       break;
  83
  84     case TYPE:
  85       return get_type_from_typealias (
  86         static_cast</*const*/ HIR::TraitItemType &> (*hir_trait_item));
  87
  88     case FN:
  89       return get_type_from_fn (
  90         static_cast</*const*/ HIR::TraitItemFunc &> (*hir_trait_item));
  91       break;
  92
  93     default:
  94       return get_error ();
  95     }
  96
  97   gcc_unreachable ();
  98   return get_error ();
  99 }
 100
 101 TyTy::ErrorType *
 102 TraitItemReference::get_error () const
 103 {
 104   return new TyTy::ErrorType (get_mappings ().get_hirid ());
 105 }
 106
 107 TraitReference::TraitReference (
 108   const HIR::Trait *hir_trait_ref, std::vector<TraitItemReference> item_refs,
 109   std::vector<const TraitReference *> super_traits,
 110   std::vector<TyTy::SubstitutionParamMapping> substs)
 111   : hir_trait_ref (hir_trait_ref), item_refs (item_refs),
 112     super_traits (super_traits)
 113 {
 114   trait_substs.clear ();
 115   trait_substs.reserve (substs.size ());
 116   for (const auto &p : substs)
 117     trait_substs.push_back (p.clone ());
 118 }
 119
 120 TraitReference::TraitReference (TraitReference const &other)
 121   : hir_trait_ref (other.hir_trait_ref), item_refs (other.item_refs),
 122     super_traits (other.super_traits)
 123 {
 124   trait_substs.clear ();
 125   trait_substs.reserve (other.trait_substs.size ());
 126   for (const auto &p : other.trait_substs)
 127     trait_substs.push_back (p.clone ());
 128 }
 129
 130 TraitReference &
 131 TraitReference::operator= (TraitReference const &other)
 132 {
 133   hir_trait_ref = other.hir_trait_ref;
 134   item_refs = other.item_refs;
 135   super_traits = other.super_traits;
 136
 137   trait_substs.clear ();
 138   trait_substs.reserve (other.trait_substs.size ());
 139   for (const auto &p : other.trait_substs)
 140     trait_substs.push_back (p.clone ());
 141
 142   return *this;
 143 }
 144
 145 bool
 146 TraitReference::is_error () const
 147 {
 148   return hir_trait_ref == nullptr;
 149 }
 150
 151 Location
 152 TraitReference::get_locus () const
 153 {
 154   return hir_trait_ref->get_locus ();
 155 }
 156
 157 std::string
 158 TraitReference::get_name () const
 159 {
 160   rust_assert (!is_error ());
 161   return hir_trait_ref->get_name ();
 162 }
 163
 164 std::string
 165 TraitReference::as_string () const
 166 {
 167   if (is_error ())
 168     return "<trait-ref-error-node>";
 169
 170   std::string item_buf;
 171   for (auto &item : item_refs)
 172     {
 173       item_buf += item.as_string () + ", ";
 174     }
 175   return "HIR Trait: " + get_name () + "->"
 176          + hir_trait_ref->get_mappings ().as_string () + " [" + item_buf + "]";
 177 }
 178
 179 const HIR::Trait *
 180 TraitReference::get_hir_trait_ref () const
 181 {
 182   return hir_trait_ref;
 183 }
 184
 185 const Analysis::NodeMapping &
 186 TraitReference::get_mappings () const
 187 {
 188   return hir_trait_ref->get_mappings ();
 189 }
 190
 191 DefId
 192 TraitReference::get_defid () const
 193 {
 194   return get_mappings ().get_defid ();
 195 }
 196
 197 bool
 198 TraitReference::lookup_hir_trait_item (const HIR::TraitItem &item,
 199                                        TraitItemReference **ref)
 200 {
 201   return lookup_trait_item (item.trait_identifier (), ref);
 202 }
 203
 204 bool
 205 TraitReference::lookup_trait_item (const std::string &ident,
 206                                    TraitItemReference **ref)
 207 {
 208   for (auto &item : item_refs)
 209     {
 210       if (ident.compare (item.get_identifier ()) == 0)
 211         {
 212           *ref = &item;
 213           return true;
 214         }
 215     }
 216   return false;
 217 }
 218
 219 bool
 220 TraitReference::lookup_trait_item_by_type (
 221   const std::string &ident, TraitItemReference::TraitItemType type,
 222   TraitItemReference **ref)
 223 {
 224   for (auto &item : item_refs)
 225     {
 226       if (item.get_trait_item_type () != type)
 227         continue;
 228
 229       if (ident.compare (item.get_identifier ()) == 0)
 230         {
 231           *ref = &item;
 232           return true;
 233         }
 234     }
 235   return false;
 236 }
 237
 238 bool
 239 TraitReference::lookup_trait_item_by_type (
 240   const std::string &ident, TraitItemReference::TraitItemType type,
 241   const TraitItemReference **ref) const
 242 {
 243   for (auto &item : item_refs)
 244     {
 245       if (item.get_trait_item_type () != type)
 246         continue;
 247
 248       if (ident.compare (item.get_identifier ()) == 0)
 249         {
 250           *ref = &item;
 251           return true;
 252         }
 253     }
 254   return false;
 255 }
 256
 257 bool
 258 TraitReference::lookup_hir_trait_item (const HIR::TraitItem &item,
 259                                        const TraitItemReference **ref) const
 260 {
 261   return lookup_trait_item (item.trait_identifier (), ref);
 262 }
 263
 264 bool
 265 TraitReference::lookup_trait_item (const std::string &ident,
 266                                    const TraitItemReference **ref) const
 267 {
 268   for (auto &item : item_refs)
 269     {
 270       if (ident.compare (item.get_identifier ()) == 0)
 271         {
 272           *ref = &item;
 273           return true;
 274         }
 275     }
 276
 277   // lookup super traits
 278   for (const auto &super_trait : super_traits)
 279     {
 280       bool found = super_trait->lookup_trait_item (ident, ref);
 281       if (found)
 282         return true;
 283     }
 284
 285   return false;
 286 }
 287
 288 const TraitItemReference *
 289 TraitReference::lookup_trait_item (const std::string &ident,
 290                                    TraitItemReference::TraitItemType type) const
 291 {
 292   for (auto &item : item_refs)
 293     {
 294       if (item.get_trait_item_type () != type)
 295         continue;
 296
 297       if (ident.compare (item.get_identifier ()) == 0)
 298         return &item;
 299     }
 300
 301   // lookup super traits
 302   for (const auto &super_trait : super_traits)
 303     {
 304       const TraitItemReference *res
 305         = super_trait->lookup_trait_item (ident, type);
 306       if (!res->is_error ())
 307         return res;
 308     }
 309
 310   return &TraitItemReference::error_node ();
 311 }
 312
 313 size_t
 314 TraitReference::size () const
 315 {
 316   return item_refs.size ();
 317 }
 318
 319 const std::vector<TraitItemReference> &
 320 TraitReference::get_trait_items () const
 321 {
 322   return item_refs;
 323 }
 324
 325 void
 326 TraitReference::get_trait_items_and_supers (
 327   std::vector<const TraitItemReference *> &result) const
 328 {
 329   for (const auto &item : item_refs)
 330     result.push_back (&item);
 331
 332   for (const auto &super_trait : super_traits)
 333     super_trait->get_trait_items_and_supers (result);
 334 }
 335
 336 void
 337 TraitReference::on_resolved ()
 338 {
 339   for (auto &item : item_refs)
 340     {
 341       item.on_resolved ();
 342     }
 343 }
 344
 345 void
 346 TraitReference::clear_associated_types () const
 347 {
 348   for (const auto &item : item_refs)
 349     {
 350       bool is_assoc_type = item.get_trait_item_type ()
 351                            == TraitItemReference::TraitItemType::TYPE;
 352       if (is_assoc_type)
 353         item.associated_type_reset (false);
 354     }
 355 }
 356
 357 void
 358 TraitReference::clear_associated_type_projections () const
 359 {
 360   for (const auto &item : item_refs)
 361     {
 362       bool is_assoc_type = item.get_trait_item_type ()
 363                            == TraitItemReference::TraitItemType::TYPE;
 364       if (is_assoc_type)
 365         item.associated_type_reset (true);
 366     }
 367 }
 368
 369 bool
 370 TraitReference::is_equal (const TraitReference &other) const
 371 {
 372   DefId this_id = get_mappings ().get_defid ();
 373   DefId other_id = other.get_mappings ().get_defid ();
 374   return this_id == other_id;
 375 }
 376
 377 const std::vector<const TraitReference *>
 378 TraitReference::get_super_traits () const
 379 {
 380   return super_traits;
 381 }
 382
 383 bool
 384 TraitReference::is_object_safe (bool emit_error, Location locus) const
 385 {
 386   // https: // doc.rust-lang.org/reference/items/traits.html#object-safety
 387   std::vector<const TraitReference *> non_object_super_traits;
 388   for (auto &item : super_traits)
 389     {
 390       if (!item->is_object_safe (false, Location ()))
 391         non_object_super_traits.push_back (item);
 392     }
 393
 394   std::vector<const Resolver::TraitItemReference *> non_object_safe_items;
 395   for (auto &item : get_trait_items ())
 396     {
 397       if (!item.is_object_safe ())
 398         non_object_safe_items.push_back (&item);
 399     }
 400
 401   bool is_safe
 402     = non_object_super_traits.empty () && non_object_safe_items.empty ();
 403   if (emit_error && !is_safe)
 404     {
 405       RichLocation r (locus);
 406       for (auto &item : non_object_super_traits)
 407         r.add_range (item->get_locus ());
 408       for (auto &item : non_object_safe_items)
 409         r.add_range (item->get_locus ());
 410
 411       rust_error_at (r, "trait bound is not object safe");
 412     }
 413
 414   return is_safe;
 415 }
 416
 417 bool
 418 TraitReference::trait_has_generics () const
 419 {
 420   return !trait_substs.empty ();
 421 }
 422
 423 std::vector<TyTy::SubstitutionParamMapping>
 424 TraitReference::get_trait_substs () const
 425 {
 426   return trait_substs;
 427 }
 428
 429 bool
 430 TraitReference::satisfies_bound (const TraitReference &reference) const
 431 {
 432   if (is_equal (reference))
 433     return true;
 434
 435   for (const auto &super_trait : super_traits)
 436     {
 437       if (super_trait->satisfies_bound (reference))
 438         return true;
 439     }
 440
 441   return false;
 442 }
 443
 444 AssociatedImplTrait::AssociatedImplTrait (TraitReference *trait,
 445                                           HIR::ImplBlock *impl,
 446                                           TyTy::BaseType *self,
 447                                           Resolver::TypeCheckContext *context)
 448   : trait (trait), impl (impl), self (self), context (context)
 449 {}
 450
 451 TraitReference *
 452 AssociatedImplTrait::get_trait ()
 453 {
 454   return trait;
 455 }
 456
 457 HIR::ImplBlock *
 458 AssociatedImplTrait::get_impl_block ()
 459 {
 460   return impl;
 461 }
 462
 463 TyTy::BaseType *
 464 AssociatedImplTrait::get_self ()
 465 {
 466   return self;
 467 }
 468 const TyTy::BaseType *
 469 AssociatedImplTrait::get_self () const
 470 {
 471   return self;
 472 }
 473
 474 } // namespace Resolver
 475 } // namespace Rust