gcc/rust/typecheck/rust-substitution-mapper.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-substitution-mapper.h"
  20 #include "rust-hir-type-check.h"
  21
  22 namespace Rust {
  23 namespace Resolver {
  24
  25 SubstMapper::SubstMapper (HirId ref, HIR::GenericArgs *generics,
  26                           const std::vector<TyTy::Region> &regions,
  27                           location_t locus)
  28   : resolved (new TyTy::ErrorType (ref)), generics (generics),
  29     regions (regions), locus (locus)
  30 {}
  31
  32 TyTy::BaseType *
  33 SubstMapper::Resolve (TyTy::BaseType *base, location_t locus,
  34                       HIR::GenericArgs *generics,
  35                       const std::vector<TyTy::Region> &regions)
  36 {
  37   SubstMapper mapper (base->get_ref (), generics, regions, locus);
  38   base->accept_vis (mapper);
  39   rust_assert (mapper.resolved != nullptr);
  40   return mapper.resolved;
  41 }
  42
  43 TyTy::BaseType *
  44 SubstMapper::InferSubst (TyTy::BaseType *base, location_t locus)
  45 {
  46   return SubstMapper::Resolve (base, locus, nullptr, {});
  47 }
  48
  49 bool
  50 SubstMapper::have_generic_args () const
  51 {
  52   return generics != nullptr;
  53 }
  54
  55 void
  56 SubstMapper::visit (TyTy::FnType &type)
  57 {
  58   TyTy::FnType *concrete = nullptr;
  59   if (!have_generic_args ())
  60     {
  61       TyTy::BaseType *substs = type.infer_substitions (locus);
  62       rust_assert (substs->get_kind () == TyTy::TypeKind::FNDEF);
  63       concrete = static_cast<TyTy::FnType *> (substs);
  64     }
  65   else
  66     {
  67       TyTy::SubstitutionArgumentMappings mappings
  68         = type.get_mappings_from_generic_args (*generics, regions);
  69       if (mappings.is_error ())
  70         return;
  71
  72       concrete = type.handle_substitions (mappings);
  73     }
  74
  75   if (concrete != nullptr)
  76     resolved = concrete;
  77 }
  78
  79 void
  80 SubstMapper::visit (TyTy::ADTType &type)
  81 {
  82   TyTy::ADTType *concrete = nullptr;
  83   if (!have_generic_args ())
  84     {
  85       TyTy::BaseType *substs = type.infer_substitions (locus);
  86       rust_assert (substs->get_kind () == TyTy::TypeKind::ADT);
  87       concrete = static_cast<TyTy::ADTType *> (substs);
  88     }
  89   else
  90     {
  91       TyTy::SubstitutionArgumentMappings mappings
  92         = type.get_mappings_from_generic_args (*generics, regions);
  93       if (mappings.is_error ())
  94         return;
  95
  96       concrete = type.handle_substitions (mappings);
  97     }
  98
  99   if (concrete != nullptr)
 100     resolved = concrete;
 101 }
 102
 103 void
 104 SubstMapper::visit (TyTy::PlaceholderType &type)
 105 {
 106   rust_assert (type.can_resolve ());
 107   resolved = SubstMapper::Resolve (type.resolve (), locus, generics, regions);
 108 }
 109
 110 void
 111 SubstMapper::visit (TyTy::ProjectionType &type)
 112 {
 113   TyTy::ProjectionType *concrete = nullptr;
 114   if (!have_generic_args ())
 115     {
 116       TyTy::BaseType *substs = type.infer_substitions (locus);
 117       rust_assert (substs->get_kind () == TyTy::TypeKind::PROJECTION);
 118       concrete = static_cast<TyTy::ProjectionType *> (substs);
 119     }
 120   else
 121     {
 122       TyTy::SubstitutionArgumentMappings mappings
 123         = type.get_mappings_from_generic_args (*generics, regions);
 124       if (mappings.is_error ())
 125         return;
 126
 127       concrete = type.handle_substitions (mappings);
 128     }
 129
 130   if (concrete != nullptr)
 131     resolved = concrete;
 132 }
 133
 134 SubstMapperInternal::SubstMapperInternal (
 135   HirId ref, TyTy::SubstitutionArgumentMappings &mappings)
 136   : resolved (new TyTy::ErrorType (ref)), mappings (mappings)
 137 {}
 138
 139 TyTy::BaseType *
 140 SubstMapperInternal::Resolve (TyTy::BaseType *base,
 141                               TyTy::SubstitutionArgumentMappings &mappings)
 142 {
 143   auto context = TypeCheckContext::get ();
 144
 145   SubstMapperInternal mapper (base->get_ref (), mappings);
 146   base->accept_vis (mapper);
 147   rust_assert (mapper.resolved != nullptr);
 148
 149   // insert these new implict types into the context
 150   TyTy::BaseType *unused = nullptr;
 151   bool is_ty_available
 152     = context->lookup_type (mapper.resolved->get_ty_ref (), &unused);
 153   if (!is_ty_available)
 154     {
 155       context->insert_type (
 156         Analysis::NodeMapping (0, 0, mapper.resolved->get_ty_ref (), 0),
 157         mapper.resolved);
 158     }
 159   bool is_ref_available
 160     = context->lookup_type (mapper.resolved->get_ref (), &unused);
 161   if (!is_ref_available)
 162     {
 163       context->insert_type (Analysis::NodeMapping (0, 0,
 164                                                    mapper.resolved->get_ref (),
 165                                                    0),
 166                             mapper.resolved);
 167     }
 168
 169   return mapper.resolved;
 170 }
 171
 172 bool
 173 SubstMapperInternal::mappings_are_bound (
 174   TyTy::BaseType *tyseg, TyTy::SubstitutionArgumentMappings &mappings)
 175 {
 176   if (tyseg->get_kind () == TyTy::TypeKind::ADT)
 177     {
 178       TyTy::ADTType *adt = static_cast<TyTy::ADTType *> (tyseg);
 179       return adt->are_mappings_bound (mappings);
 180     }
 181   else if (tyseg->get_kind () == TyTy::TypeKind::FNDEF)
 182     {
 183       TyTy::FnType *fn = static_cast<TyTy::FnType *> (tyseg);
 184       return fn->are_mappings_bound (mappings);
 185     }
 186
 187   return false;
 188 }
 189
 190 void
 191 SubstMapperInternal::visit (TyTy::FnType &type)
 192 {
 193   TyTy::SubstitutionArgumentMappings adjusted
 194     = type.adjust_mappings_for_this (mappings);
 195   if (adjusted.is_error ())
 196     return;
 197
 198   TyTy::BaseType *concrete = type.handle_substitions (adjusted);
 199   if (concrete != nullptr)
 200     resolved = concrete;
 201 }
 202
 203 void
 204 SubstMapperInternal::visit (TyTy::ADTType &type)
 205 {
 206   TyTy::SubstitutionArgumentMappings adjusted
 207     = type.adjust_mappings_for_this (mappings);
 208   if (adjusted.is_error ())
 209     return;
 210
 211   TyTy::BaseType *concrete = type.handle_substitions (adjusted);
 212   if (concrete != nullptr)
 213     resolved = concrete;
 214 }
 215
 216 // these don't support generic arguments but might contain a type param
 217 void
 218 SubstMapperInternal::visit (TyTy::TupleType &type)
 219 {
 220   resolved = type.handle_substitions (mappings);
 221 }
 222
 223 void
 224 SubstMapperInternal::visit (TyTy::ReferenceType &type)
 225 {
 226   resolved = type.handle_substitions (mappings);
 227 }
 228
 229 void
 230 SubstMapperInternal::visit (TyTy::PointerType &type)
 231 {
 232   resolved = type.handle_substitions (mappings);
 233 }
 234
 235 void
 236 SubstMapperInternal::visit (TyTy::ParamType &type)
 237 {
 238   resolved = type.handle_substitions (mappings);
 239 }
 240
 241 void
 242 SubstMapperInternal::visit (TyTy::PlaceholderType &type)
 243 {
 244   rust_assert (type.can_resolve ());
 245   if (mappings.trait_item_mode ())
 246     {
 247       resolved = type.resolve ();
 248     }
 249   else
 250     {
 251       resolved = SubstMapperInternal::Resolve (type.resolve (), mappings);
 252     }
 253 }
 254
 255 void
 256 SubstMapperInternal::visit (TyTy::ProjectionType &type)
 257 {
 258   resolved = type.handle_substitions (mappings);
 259 }
 260
 261 void
 262 SubstMapperInternal::visit (TyTy::ClosureType &type)
 263 {
 264   resolved = type.handle_substitions (mappings);
 265 }
 266
 267 void
 268 SubstMapperInternal::visit (TyTy::ArrayType &type)
 269 {
 270   resolved = type.handle_substitions (mappings);
 271 }
 272
 273 void
 274 SubstMapperInternal::visit (TyTy::SliceType &type)
 275 {
 276   resolved = type.handle_substitions (mappings);
 277 }
 278
 279 // nothing to do for these
 280 void
 281 SubstMapperInternal::visit (TyTy::InferType &type)
 282 {
 283   resolved = type.clone ();
 284 }
 285 void
 286 SubstMapperInternal::visit (TyTy::FnPtr &type)
 287 {
 288   resolved = type.clone ();
 289 }
 290 void
 291 SubstMapperInternal::visit (TyTy::BoolType &type)
 292 {
 293   resolved = type.clone ();
 294 }
 295 void
 296 SubstMapperInternal::visit (TyTy::IntType &type)
 297 {
 298   resolved = type.clone ();
 299 }
 300 void
 301 SubstMapperInternal::visit (TyTy::UintType &type)
 302 {
 303   resolved = type.clone ();
 304 }
 305 void
 306 SubstMapperInternal::visit (TyTy::FloatType &type)
 307 {
 308   resolved = type.clone ();
 309 }
 310 void
 311 SubstMapperInternal::visit (TyTy::USizeType &type)
 312 {
 313   resolved = type.clone ();
 314 }
 315 void
 316 SubstMapperInternal::visit (TyTy::ISizeType &type)
 317 {
 318   resolved = type.clone ();
 319 }
 320 void
 321 SubstMapperInternal::visit (TyTy::ErrorType &type)
 322 {
 323   resolved = type.clone ();
 324 }
 325 void
 326 SubstMapperInternal::visit (TyTy::CharType &type)
 327 {
 328   resolved = type.clone ();
 329 }
 330 void
 331 SubstMapperInternal::visit (TyTy::StrType &type)
 332 {
 333   resolved = type.clone ();
 334 }
 335 void
 336 SubstMapperInternal::visit (TyTy::NeverType &type)
 337 {
 338   resolved = type.clone ();
 339 }
 340 void
 341 SubstMapperInternal::visit (TyTy::DynamicObjectType &type)
 342 {
 343   resolved = type.clone ();
 344 }
 345
 346 // SubstMapperFromExisting
 347
 348 SubstMapperFromExisting::SubstMapperFromExisting (TyTy::BaseType *concrete,
 349                                                   TyTy::BaseType *receiver)
 350   : concrete (concrete), receiver (receiver), resolved (nullptr)
 351 {}
 352
 353 TyTy::BaseType *
 354 SubstMapperFromExisting::Resolve (TyTy::BaseType *concrete,
 355                                   TyTy::BaseType *receiver)
 356 {
 357   rust_assert (concrete->get_kind () == receiver->get_kind ());
 358
 359   SubstMapperFromExisting mapper (concrete, receiver);
 360   concrete->accept_vis (mapper);
 361   return mapper.resolved;
 362 }
 363
 364 void
 365 SubstMapperFromExisting::visit (TyTy::FnType &type)
 366 {
 367   rust_assert (type.was_substituted ());
 368
 369   TyTy::FnType *to_sub = static_cast<TyTy::FnType *> (receiver);
 370   resolved = to_sub->handle_substitions (type.get_substitution_arguments ());
 371 }
 372
 373 void
 374 SubstMapperFromExisting::visit (TyTy::ADTType &type)
 375 {
 376   rust_assert (type.was_substituted ());
 377
 378   TyTy::ADTType *to_sub = static_cast<TyTy::ADTType *> (receiver);
 379   resolved = to_sub->handle_substitions (type.get_substitution_arguments ());
 380 }
 381
 382 void
 383 SubstMapperFromExisting::visit (TyTy::ClosureType &type)
 384 {
 385   rust_assert (type.was_substituted ());
 386
 387   TyTy::ClosureType *to_sub = static_cast<TyTy::ClosureType *> (receiver);
 388   resolved = to_sub->handle_substitions (type.get_substitution_arguments ());
 389 }
 390
 391 // GetUsedSubstArgs
 392
 393 GetUsedSubstArgs::GetUsedSubstArgs ()
 394   : args (TyTy::SubstitutionArgumentMappings::error ())
 395 {}
 396
 397 TyTy::SubstitutionArgumentMappings
 398 GetUsedSubstArgs::From (const TyTy::BaseType *from)
 399 {
 400   GetUsedSubstArgs mapper;
 401   from->accept_vis (mapper);
 402   return mapper.args;
 403 }
 404
 405 void
 406 GetUsedSubstArgs::visit (const TyTy::FnType &type)
 407 {
 408   args = type.get_substitution_arguments ();
 409 }
 410
 411 void
 412 GetUsedSubstArgs::visit (const TyTy::ADTType &type)
 413 {
 414   args = type.get_substitution_arguments ();
 415 }
 416
 417 void
 418 GetUsedSubstArgs::visit (const TyTy::ClosureType &type)
 419 {
 420   args = type.get_substitution_arguments ();
 421 }
 422
 423 } // namespace Resolver
 424 } // namespace Rust