LCOV - code coverage report
Current view: top level - gcc/rust/typecheck - rust-unify.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 85.0 % 1458 1239
Test Date: 2026-11-14 16:39:50 Functions: 88.6 % 35 31
Legend: Lines:     hit not hit

            Line data    Source code
       1              : // Copyright (C) 2020-2026 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-unify.h"
      20              : #include "fold-const.h"
      21              : #include "rust-tyty-util.h"
      22              : #include "rust-tyty.h"
      23              : #include "rust-type-util.h"
      24              : 
      25              : namespace Rust {
      26              : namespace Resolver {
      27              : 
      28              : static TyTy::BaseType *
      29      5494079 : unify_error_type_node ()
      30              : {
      31      5494079 :   static TyTy::BaseType *error = nullptr;
      32      5494079 :   if (error == nullptr)
      33         1308 :     error = new TyTy::ErrorType (0);
      34      5494079 :   return error;
      35              : }
      36              : 
      37      6532085 : UnifyRules::UnifyRules (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
      38              :                         location_t locus, bool commit_flag, bool emit_error,
      39              :                         bool check_bounds, bool infer,
      40              :                         std::vector<CommitSite> &commits,
      41              :                         std::vector<InferenceSite> &infers,
      42              :                         ActiveADTs &active_adts, bool allow_never_coercion)
      43      6532085 :   : lhs (lhs), rhs (rhs), locus (locus), commit_flag (commit_flag),
      44      6532085 :     emit_error (emit_error), infer_flag (infer),
      45      6532085 :     check_bounds_flag (check_bounds),
      46      6532085 :     allow_never_coercion (allow_never_coercion), commits (commits),
      47      6532085 :     infers (infers), active_adts (active_adts),
      48      6532085 :     mappings (Analysis::Mappings::get ()), context (*TypeCheckContext::get ())
      49      6532085 : {}
      50              : 
      51              : TyTy::BaseType *
      52      6532085 : UnifyRules::Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
      53              :                      location_t locus, bool commit_flag, bool emit_error,
      54              :                      bool check_bounds, bool infer,
      55              :                      std::vector<CommitSite> &commits,
      56              :                      std::vector<InferenceSite> &infers,
      57              :                      ActiveADTs *active_adts, bool allow_never_coercion)
      58              : {
      59      6532085 :   ActiveADTs root_active_adts;
      60      6532085 :   if (active_adts == nullptr)
      61      6199726 :     active_adts = &root_active_adts;
      62              : 
      63      6532085 :   UnifyRules r (lhs, rhs, locus, commit_flag, emit_error, check_bounds, infer,
      64      6532085 :                 commits, infers, *active_adts, allow_never_coercion);
      65              : 
      66      6532085 :   TyTy::BaseType *result = r.go ();
      67      6532064 :   bool failed = result->get_kind () == TyTy::TypeKind::ERROR;
      68              : 
      69      6532064 :   commits.emplace_back (lhs.get_ty (), rhs.get_ty (), result);
      70      6532064 :   if (r.commit_flag && !failed)
      71              :     {
      72        58634 :       result = result->clone ();
      73        58634 :       UnifyRules::commit (lhs.get_ty (), rhs.get_ty (), result);
      74              :     }
      75              : 
      76      6532064 :   if (failed && r.emit_error)
      77           71 :     r.emit_type_mismatch ();
      78              : 
      79      6532064 :   return result;
      80      6532064 : }
      81              : 
      82              : TyTy::BaseType *
      83       332359 : UnifyRules::resolve_subtype (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs)
      84              : {
      85       332359 :   TyTy::BaseType *result
      86       664711 :     = UnifyRules::Resolve (lhs, rhs, locus, commit_flag, emit_error,
      87              :                            check_bounds_flag, infer_flag, commits, infers,
      88       332359 :                            &active_adts, allow_never_coercion);
      89              : 
      90              :   // If the recursive call resulted in an error and would have emitted an error
      91              :   // message, disable error emission for the current level to avoid duplicate
      92              :   // errors
      93       332352 :   if (result->get_kind () == TyTy::TypeKind::ERROR && emit_error)
      94           27 :     emit_error = false;
      95              : 
      96       332352 :   return result;
      97              : }
      98              : 
      99              : TyTy::BaseType *
     100            0 : UnifyRules::get_base ()
     101              : {
     102            0 :   return lhs.get_ty ()->destructure ();
     103              : }
     104              : 
     105              : TyTy::BaseType *
     106            0 : UnifyRules::get_other ()
     107              : {
     108            0 :   return rhs.get_ty ()->destructure ();
     109              : }
     110              : 
     111              : void
     112       235494 : UnifyRules::commit (TyTy::BaseType *base, TyTy::BaseType *other,
     113              :                     TyTy::BaseType *resolved)
     114              : {
     115       235494 :   TypeCheckContext &context = *TypeCheckContext::get ();
     116              : 
     117       235494 :   TyTy::BaseType *b = base->destructure ();
     118       235494 :   TyTy::BaseType *o = other->destructure ();
     119              : 
     120       235494 :   resolved->append_reference (b->get_ref ());
     121       235494 :   resolved->append_reference (o->get_ref ());
     122      1868698 :   for (auto ref : b->get_combined_refs ())
     123      1633204 :     resolved->append_reference (ref);
     124      1686489 :   for (auto ref : o->get_combined_refs ())
     125      1450995 :     resolved->append_reference (ref);
     126              : 
     127       235494 :   o->append_reference (resolved->get_ref ());
     128       235494 :   o->append_reference (b->get_ref ());
     129       235494 :   b->append_reference (resolved->get_ref ());
     130       235494 :   b->append_reference (o->get_ref ());
     131              : 
     132       235494 :   if (resolved->get_kind () != TyTy::TypeKind::CONST)
     133              :     {
     134       233893 :       bool result_resolved = resolved->get_kind () != TyTy::TypeKind::INFER;
     135       233893 :       bool result_is_infer_var = resolved->get_kind () == TyTy::TypeKind::INFER;
     136       233893 :       bool results_is_non_general_infer_var
     137              :         = (result_is_infer_var
     138       233893 :            && (static_cast<TyTy::InferType *> (resolved))->get_infer_kind ()
     139       461757 :                 != TyTy::InferType::GENERAL);
     140       228044 :       if (result_resolved || results_is_non_general_infer_var)
     141              :         {
     142      2284340 :           for (auto &ref : resolved->get_combined_refs ())
     143              :             {
     144      2050627 :               TyTy::BaseType *ref_tyty = nullptr;
     145      2050627 :               bool ok = context.lookup_type (ref, &ref_tyty);
     146      2050627 :               if (!ok)
     147         3456 :                 continue;
     148              : 
     149              :               // if any of the types are inference variables lets fix them
     150      2047171 :               if (ref_tyty->is<TyTy::InferType> ())
     151        84951 :                 context.insert_implicit_type (ref, resolved);
     152       233713 :             }
     153              :         }
     154              :     }
     155              :   else
     156              :     {
     157         1601 :       auto base_const = resolved->as_const_type ();
     158         1601 :       if (base_const->const_kind () == TyTy::BaseConstType::ConstKind::Value)
     159              :         {
     160         1578 :           rust_debug ("UnifyRules::commit const value, resolved_ref=%u "
     161              :                       "resolved_ty_ref=%u combined_refs.size=%zu",
     162              :                       resolved->get_ref (), resolved->get_ty_ref (),
     163              :                       resolved->get_combined_refs ().size ());
     164              : 
     165         4835 :           for (auto &ref : resolved->get_combined_refs ())
     166              :             {
     167         3257 :               TyTy::BaseType *ref_tyty = nullptr;
     168         3257 :               bool ok = context.lookup_type (ref, &ref_tyty);
     169         3257 :               if (!ok)
     170            0 :                 continue;
     171         3257 :               if (ref_tyty->get_kind () != TyTy::TypeKind::CONST)
     172            0 :                 continue;
     173              : 
     174         3257 :               auto ref_base_const = ref_tyty->as_const_type ();
     175         3257 :               if (ref_base_const->const_kind ()
     176              :                     == TyTy::BaseConstType::ConstKind::Infer
     177         3257 :                   || ref_base_const->const_kind ()
     178              :                        == TyTy::BaseConstType::ConstKind::Decl)
     179              :                 {
     180           63 :                   rust_debug ("  committing to ref=%u kind=%d", ref,
     181              :                               (int) ref_base_const->const_kind ());
     182           63 :                   context.insert_implicit_type (ref, resolved);
     183              :                 }
     184         1578 :             }
     185              :         }
     186              :     }
     187       235494 : }
     188              : 
     189              : void
     190           71 : UnifyRules::emit_type_mismatch () const
     191              : {
     192           71 :   TyTy::BaseType *expected = lhs.get_ty ();
     193           71 :   TyTy::BaseType *expr = rhs.get_ty ();
     194              : 
     195           71 :   rich_location r (line_table, locus);
     196           71 :   r.add_range (lhs.get_locus ());
     197           71 :   r.add_range (rhs.get_locus ());
     198           71 :   rust_error_at (r, ErrorCode::E0308,
     199              :                  "mismatched types, expected %qs but got %qs",
     200          142 :                  expected->get_name ().c_str (), expr->get_name ().c_str ());
     201           71 : }
     202              : 
     203              : void
     204            0 : UnifyRules::emit_abi_mismatch (const TyTy::FnType &expected,
     205              :                                const TyTy::FnType &got) const
     206              : {
     207            0 :   rich_location r (line_table, locus);
     208            0 :   r.add_range (lhs.get_locus ());
     209            0 :   r.add_range (rhs.get_locus ());
     210            0 :   rust_error_at (r, "mistached abi %qs got %qs",
     211            0 :                  get_string_from_abi (expected.get_abi ()).c_str (),
     212            0 :                  get_string_from_abi (got.get_abi ()).c_str ());
     213            0 : }
     214              : 
     215              : TyTy::BaseType *
     216      6532085 : UnifyRules::go ()
     217              : {
     218      6532085 :   TyTy::BaseType *ltype = lhs.get_ty ()->destructure ();
     219      6532085 :   TyTy::BaseType *rtype = rhs.get_ty ()->destructure ();
     220              : 
     221      6532085 :   rust_debug ("unify::go ltype={%s} rtype={%s}", ltype->debug_str ().c_str (),
     222              :               rtype->debug_str ().c_str ());
     223              : 
     224      6532085 :   if (check_bounds_flag)
     225              :     {
     226      1414228 :       bool ltype_is_placeholder
     227      1414228 :         = ltype->get_kind () == TyTy::TypeKind::PLACEHOLDER;
     228      1414228 :       bool rtype_is_placeholder
     229      1414228 :         = rtype->get_kind () == TyTy::TypeKind::PLACEHOLDER;
     230      1414228 :       bool types_equal = ltype->is_equal (*rtype);
     231      9091700 :       bool should_check_bounds
     232      1414228 :         = !types_equal && !(ltype_is_placeholder || rtype_is_placeholder);
     233      1152465 :       if (should_check_bounds)
     234              :         {
     235      1152465 :           if (ltype->num_specified_bounds () > 0)
     236              :             {
     237        40617 :               if (!ltype->bounds_compatible (*rtype, locus, emit_error))
     238              :                 {
     239              :                   // already emitted an error
     240         6934 :                   emit_error = false;
     241         6934 :                   return unify_error_type_node ();
     242              :                 }
     243              :             }
     244      1111848 :           else if (rtype->num_specified_bounds () > 0)
     245              :             {
     246         9829 :               if (!rtype->bounds_compatible (*ltype, locus, emit_error))
     247              :                 {
     248              :                   // already emitted an error
     249          130 :                   emit_error = false;
     250          130 :                   return unify_error_type_node ();
     251              :                 }
     252              :             }
     253              :         }
     254              :     }
     255      6525007 :   if (infer_flag)
     256              :     {
     257              :       // an impl parameter can infer to Split<T, P> without requiring T and P to
     258              :       // be concrete
     259      6339175 :       bool rgot_param = rtype->get_kind () == TyTy::TypeKind::PARAM;
     260      6339175 :       bool lhs_is_infer_var = ltype->get_kind () == TyTy::TypeKind::INFER;
     261      6339175 :       bool lhs_is_general_infer_var
     262              :         = lhs_is_infer_var
     263      6339175 :           && static_cast<TyTy::InferType *> (ltype)->get_infer_kind ()
     264      6339175 :                == TyTy::InferType::GENERAL;
     265      6339175 :       bool expected_can_infer_param
     266      6387258 :         = (ltype->is_concrete () || ltype->get_kind () == TyTy::TypeKind::ADT)
     267      6342324 :           && !lhs_is_general_infer_var;
     268      6339175 :       bool rneeds_infer = expected_can_infer_param && rgot_param;
     269              : 
     270      6339175 :       bool lgot_param = ltype->get_kind () == TyTy::TypeKind::PARAM;
     271      6339175 :       bool rhs_is_infer_var = rtype->get_kind () == TyTy::TypeKind::INFER;
     272      6339175 :       bool rhs_is_general_infer_var
     273              :         = rhs_is_infer_var
     274      6339175 :           && static_cast<TyTy::InferType *> (rtype)->get_infer_kind ()
     275      6339175 :                == TyTy::InferType::GENERAL;
     276      6339175 :       bool receiver_can_infer_param
     277      8289571 :         = (rtype->is_concrete () || rtype->get_kind () == TyTy::TypeKind::ADT)
     278      6660532 :           && !rhs_is_general_infer_var;
     279      6339175 :       bool lneeds_infer = receiver_can_infer_param && lgot_param;
     280              : 
     281      6339175 :       if (rneeds_infer)
     282              :         {
     283        42386 :           TyTy::ParamType *p = static_cast<TyTy::ParamType *> (rtype);
     284        42386 :           TyTy::TyVar iv
     285        42386 :             = TyTy::TyVar::get_implicit_infer_var (rhs.get_locus ());
     286        42386 :           rust_assert (iv.get_tyty ()->get_kind () == TyTy::TypeKind::INFER);
     287        42386 :           TyTy::InferType *i = static_cast<TyTy::InferType *> (iv.get_tyty ());
     288              : 
     289        42386 :           infers.emplace_back (p->get_ref (), p->get_ty_ref (), p, i);
     290              : 
     291              :           // FIXME
     292              :           // this is hacky to set the implicit param lets make this a function
     293        42386 :           p->set_ty_ref (i->get_ref ());
     294              : 
     295              :           // set the rtype now to the new inference var
     296        42386 :           rtype = i;
     297              :         }
     298      6296789 :       else if (lneeds_infer)
     299              :         {
     300         1922 :           TyTy::ParamType *p = static_cast<TyTy::ParamType *> (ltype);
     301         1922 :           TyTy::TyVar iv
     302         1922 :             = TyTy::TyVar::get_implicit_infer_var (lhs.get_locus ());
     303         1922 :           rust_assert (iv.get_tyty ()->get_kind () == TyTy::TypeKind::INFER);
     304         1922 :           TyTy::InferType *i = static_cast<TyTy::InferType *> (iv.get_tyty ());
     305              : 
     306         1922 :           infers.emplace_back (p->get_ref (), p->get_ty_ref (), p, i);
     307              : 
     308              :           // FIXME
     309              :           // this is hacky to set the implicit param lets make this a function
     310         1922 :           p->set_ty_ref (i->get_ref ());
     311              : 
     312              :           // set the rtype now to the new inference var
     313         1922 :           ltype = i;
     314              :         }
     315      6294867 :       else if (ltype->get_kind () == TyTy::TypeKind::CONST
     316      6294867 :                && rtype->get_kind () == TyTy::TypeKind::CONST)
     317              :         {
     318          991 :           auto lhs = ltype->as_const_type ();
     319          991 :           auto rhs = rtype->as_const_type ();
     320              : 
     321          991 :           bool both_are_decls
     322          991 :             = lhs->const_kind () == TyTy::BaseConstType::ConstKind::Decl
     323          991 :               && rhs->const_kind () == TyTy::BaseConstType::ConstKind::Decl;
     324          991 :           bool have_decls
     325          991 :             = lhs->const_kind () == TyTy::BaseConstType::ConstKind::Decl
     326          991 :               || rhs->const_kind () == TyTy::BaseConstType::ConstKind::Decl;
     327              : 
     328          991 :           if (have_decls && !both_are_decls)
     329              :             {
     330           44 :               if (lhs->const_kind () == TyTy::BaseConstType::ConstKind::Decl)
     331              :                 {
     332            7 :                   auto l = lhs->as_base_type ()->get_locus ();
     333            7 :                   auto p = static_cast<TyTy::ConstParamType *> (lhs);
     334            7 :                   auto it = TyTy::TyVar::get_implicit_infer_var (l);
     335            7 :                   auto iv = TyTy::TyVar::get_implicit_const_infer_var (l, &it);
     336            7 :                   auto ivt = iv.get_tyty ();
     337              : 
     338            7 :                   infers.emplace_back (0, 0, nullptr, it.get_tyty ());
     339            7 :                   infers.emplace_back (ltype->get_ref (), ltype->get_ty_ref (),
     340              :                                        p, ivt);
     341              : 
     342            7 :                   ltype = ivt;
     343            7 :                   p->set_ty_ref (ltype->get_ref ());
     344              :                 }
     345           37 :               else if (rhs->const_kind ()
     346              :                        == TyTy::BaseConstType::ConstKind::Decl)
     347              :                 {
     348           37 :                   auto l = rhs->as_base_type ()->get_locus ();
     349           37 :                   auto p = static_cast<TyTy::ConstParamType *> (rhs);
     350           37 :                   auto it = TyTy::TyVar::get_implicit_infer_var (l);
     351           37 :                   auto iv = TyTy::TyVar::get_implicit_const_infer_var (l, &it);
     352           37 :                   auto ivt = iv.get_tyty ();
     353              : 
     354           37 :                   infers.emplace_back (0, 0, nullptr, it.get_tyty ());
     355           37 :                   infers.emplace_back (rtype->get_ref (), rtype->get_ty_ref (),
     356              :                                        p, ivt);
     357              : 
     358           37 :                   rtype = ivt;
     359           37 :                   p->set_ty_ref (rtype->get_ref ());
     360              :                 }
     361              :             }
     362              :         }
     363              :       // For PROJECTION vs PROJECTION, expect_projection handles the structural
     364              :       // comparison directly. InferSubst on projections creates fresh infer vars
     365              :       // that are not tracked in `infers` and thus leak when commit=false.
     366              :     }
     367              : 
     368      6525007 :   if (ltype->get_kind () != TyTy::TypeKind::CONST
     369      6525007 :       && rtype->get_kind () == TyTy::TypeKind::CONST)
     370              :     {
     371           29 :       auto *rc = rtype->as_const_type ();
     372           29 :       rtype = rc->get_specified_type ();
     373              :     }
     374              : 
     375      6525007 :   if (ltype->get_kind () == TyTy::TypeKind::CONST
     376      6525007 :       && rtype->get_kind () != TyTy::TypeKind::CONST)
     377              :     {
     378            9 :       auto *lc = ltype->as_const_type ();
     379            9 :       ltype = lc->get_specified_type ();
     380              :     }
     381              : 
     382      6525007 :   if (ltype->get_kind () != TyTy::TypeKind::PROJECTION
     383      6525007 :       && rtype->get_kind () == TyTy::TypeKind::PROJECTION)
     384              :     {
     385          401 :       auto *rtype_proj = static_cast<TyTy::ProjectionType *> (rtype);
     386          401 :       rtype = normalize_projection (rtype_proj, locus, false, false);
     387              :     }
     388              : 
     389      6525007 :   switch (ltype->get_kind ())
     390              :     {
     391       426727 :     case TyTy::INFER:
     392       426727 :       return expect_inference_variable (static_cast<TyTy::InferType *> (ltype),
     393       426727 :                                         rtype);
     394              : 
     395       887522 :     case TyTy::ADT:
     396       887522 :       return expect_adt (static_cast<TyTy::ADTType *> (ltype), rtype);
     397              : 
     398         7396 :     case TyTy::STR:
     399         7396 :       return expect_str (static_cast<TyTy::StrType *> (ltype), rtype);
     400              : 
     401      2502280 :     case TyTy::REF:
     402      2502280 :       return expect_reference (static_cast<TyTy::ReferenceType *> (ltype),
     403      2502280 :                                rtype);
     404              : 
     405        19462 :     case TyTy::POINTER:
     406        19462 :       return expect_pointer (static_cast<TyTy::PointerType *> (ltype), rtype);
     407              : 
     408        20066 :     case TyTy::PARAM:
     409        20066 :       return expect_param (static_cast<TyTy::ParamType *> (ltype), rtype);
     410              : 
     411         2181 :     case TyTy::ARRAY:
     412         2181 :       return expect_array (static_cast<TyTy::ArrayType *> (ltype), rtype);
     413              : 
     414         2814 :     case TyTy::SLICE:
     415         2814 :       return expect_slice (static_cast<TyTy::SliceType *> (ltype), rtype);
     416              : 
     417         6934 :     case TyTy::FNDEF:
     418         6934 :       return expect_fndef (static_cast<TyTy::FnType *> (ltype), rtype);
     419              : 
     420         4966 :     case TyTy::FNPTR:
     421         4966 :       return expect_fnptr (static_cast<TyTy::FnPtr *> (ltype), rtype);
     422              : 
     423        16341 :     case TyTy::TUPLE:
     424        16341 :       return expect_tuple (static_cast<TyTy::TupleType *> (ltype), rtype);
     425              : 
     426        23311 :     case TyTy::BOOL:
     427        23311 :       return expect_bool (static_cast<TyTy::BoolType *> (ltype), rtype);
     428              : 
     429         3158 :     case TyTy::CHAR:
     430         3158 :       return expect_char (static_cast<TyTy::CharType *> (ltype), rtype);
     431              : 
     432      1813357 :     case TyTy::INT:
     433      1813357 :       return expect_int (static_cast<TyTy::IntType *> (ltype), rtype);
     434              : 
     435       471215 :     case TyTy::UINT:
     436       471215 :       return expect_uint (static_cast<TyTy::UintType *> (ltype), rtype);
     437              : 
     438        76394 :     case TyTy::FLOAT:
     439        76394 :       return expect_float (static_cast<TyTy::FloatType *> (ltype), rtype);
     440              : 
     441       122816 :     case TyTy::USIZE:
     442       122816 :       return expect_usize (static_cast<TyTy::USizeType *> (ltype), rtype);
     443              : 
     444        93121 :     case TyTy::ISIZE:
     445        93121 :       return expect_isize (static_cast<TyTy::ISizeType *> (ltype), rtype);
     446              : 
     447          398 :     case TyTy::NEVER:
     448          398 :       return expect_never (static_cast<TyTy::NeverType *> (ltype), rtype);
     449              : 
     450            0 :     case TyTy::PLACEHOLDER:
     451            0 :       return expect_placeholder (static_cast<TyTy::PlaceholderType *> (ltype),
     452            0 :                                  rtype);
     453              : 
     454        18113 :     case TyTy::PROJECTION:
     455        18113 :       return expect_projection (static_cast<TyTy::ProjectionType *> (ltype),
     456        18113 :                                 rtype);
     457              : 
     458         4206 :     case TyTy::DYNAMIC:
     459         4206 :       return expect_dyn (static_cast<TyTy::DynamicObjectType *> (ltype), rtype);
     460              : 
     461          168 :     case TyTy::CLOSURE:
     462          168 :       return expect_closure (static_cast<TyTy::ClosureType *> (ltype), rtype);
     463              : 
     464          249 :     case TyTy::OPAQUE:
     465          249 :       return expect_opaque (static_cast<TyTy::OpaqueType *> (ltype), rtype);
     466              : 
     467         1810 :     case TyTy::CONST:
     468         1810 :       return expect_const (ltype->as_const_type (), rtype);
     469              : 
     470            2 :     case TyTy::ERROR:
     471            2 :       return unify_error_type_node ();
     472              :     }
     473              : 
     474            0 :   return unify_error_type_node ();
     475              : }
     476              : 
     477              : TyTy::BaseType *
     478       426727 : UnifyRules::expect_inference_variable (TyTy::InferType *ltype,
     479              :                                        TyTy::BaseType *rtype)
     480              : {
     481       426727 :   switch (rtype->get_kind ())
     482              :     {
     483         6729 :     case TyTy::INFER:
     484         6729 :       {
     485         6729 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
     486         6729 :         switch (ltype->get_infer_kind ())
     487              :           {
     488              :           case TyTy::InferType::InferTypeKind::GENERAL:
     489              :             return rtype;
     490              : 
     491         4756 :           case TyTy::InferType::InferTypeKind::INTEGRAL:
     492         4756 :             {
     493         4756 :               bool is_valid = r->get_infer_kind ()
     494              :                                 == TyTy::InferType::InferTypeKind::INTEGRAL
     495         4756 :                               || r->get_infer_kind ()
     496              :                                    == TyTy::InferType::InferTypeKind::GENERAL;
     497              :               if (is_valid)
     498              :                 return rtype;
     499              :             }
     500              :             break;
     501              : 
     502           50 :           case TyTy::InferType::InferTypeKind::FLOAT:
     503           50 :             {
     504           50 :               bool is_valid
     505           50 :                 = r->get_infer_kind () == TyTy::InferType::InferTypeKind::FLOAT
     506           50 :                   || r->get_infer_kind ()
     507              :                        == TyTy::InferType::InferTypeKind::GENERAL;
     508              :               if (is_valid)
     509              :                 return rtype;
     510              :             }
     511              :             break;
     512              :           }
     513              :       }
     514              :       break;
     515              : 
     516        10135 :     case TyTy::INT:
     517        10135 :     case TyTy::UINT:
     518        10135 :     case TyTy::USIZE:
     519        10135 :     case TyTy::ISIZE:
     520        10135 :       {
     521        10135 :         bool is_valid = (ltype->get_infer_kind ()
     522              :                          == TyTy::InferType::InferTypeKind::GENERAL)
     523        10135 :                         || (ltype->get_infer_kind ()
     524              :                             == TyTy::InferType::InferTypeKind::INTEGRAL);
     525              :         if (is_valid)
     526              :           {
     527        10135 :             if (commit_flag)
     528         2449 :               ltype->apply_primitive_type_hint (*rtype);
     529              :             return rtype;
     530              :           }
     531              :       }
     532              :       break;
     533              : 
     534          418 :     case TyTy::FLOAT:
     535          418 :       {
     536          418 :         bool is_valid = (ltype->get_infer_kind ()
     537              :                          == TyTy::InferType::InferTypeKind::GENERAL)
     538          418 :                         || (ltype->get_infer_kind ()
     539              :                             == TyTy::InferType::InferTypeKind::FLOAT);
     540              :         if (is_valid)
     541              :           {
     542          418 :             if (commit_flag)
     543           97 :               ltype->apply_primitive_type_hint (*rtype);
     544              :             return rtype;
     545              :           }
     546              :       }
     547              :       break;
     548              : 
     549       409445 :     case TyTy::ADT:
     550       409445 :     case TyTy::STR:
     551       409445 :     case TyTy::REF:
     552       409445 :     case TyTy::POINTER:
     553       409445 :     case TyTy::PARAM:
     554       409445 :     case TyTy::ARRAY:
     555       409445 :     case TyTy::SLICE:
     556       409445 :     case TyTy::FNDEF:
     557       409445 :     case TyTy::FNPTR:
     558       409445 :     case TyTy::TUPLE:
     559       409445 :     case TyTy::BOOL:
     560       409445 :     case TyTy::CHAR:
     561       409445 :     case TyTy::NEVER:
     562       409445 :     case TyTy::PLACEHOLDER:
     563       409445 :     case TyTy::PROJECTION:
     564       409445 :     case TyTy::DYNAMIC:
     565       409445 :     case TyTy::CLOSURE:
     566       409445 :     case TyTy::CONST:
     567       409445 :     case TyTy::OPAQUE:
     568       409445 :       {
     569       409445 :         bool is_valid = (ltype->get_infer_kind ()
     570       409445 :                          == TyTy::InferType::InferTypeKind::GENERAL);
     571       409445 :         if (is_valid)
     572              :           return rtype;
     573              :       }
     574              :       break;
     575              : 
     576            0 :     case TyTy::ERROR:
     577            0 :       return unify_error_type_node ();
     578              :     }
     579              : 
     580       223725 :   return unify_error_type_node ();
     581              : }
     582              : 
     583              : TyTy::BaseType *
     584       887522 : UnifyRules::expect_adt (TyTy::ADTType *ltype, TyTy::BaseType *rtype)
     585              : {
     586       887522 :   switch (rtype->get_kind ())
     587              :     {
     588       182130 :     case TyTy::INFER:
     589       182130 :       {
     590       182130 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
     591       182130 :         bool is_valid
     592       182130 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
     593       182130 :         if (is_valid)
     594              :           return ltype;
     595              :       }
     596              :       break;
     597              : 
     598       160056 :     case TyTy::ADT:
     599       160056 :       {
     600       160056 :         TyTy::ADTType &type = *static_cast<TyTy::ADTType *> (rtype);
     601       160056 :         if (ltype == &type)
     602              :           return ltype;
     603              : 
     604       150908 :         if (ltype->get_adt_kind () != type.get_adt_kind ())
     605              :           {
     606         3618 :             return unify_error_type_node ();
     607              :           }
     608              : 
     609       147290 :         if (ltype->get_id () != type.get_id ())
     610              :           {
     611         8823 :             return unify_error_type_node ();
     612              :           }
     613              : 
     614       415401 :         if (ltype->get_identifier ().compare (type.get_identifier ()) != 0)
     615              :           {
     616            0 :             return unify_error_type_node ();
     617              :           }
     618              : 
     619       138467 :         if (ltype->number_of_variants () != type.number_of_variants ())
     620              :           {
     621            0 :             return unify_error_type_node ();
     622              :           }
     623              : 
     624       138467 :         ActiveADTGuard guard (active_adts, {ltype, &type});
     625       138467 :         if (guard.already_active ())
     626              :           return ltype;
     627              : 
     628       245802 :         for (size_t i = 0; i < type.number_of_variants (); ++i)
     629              :           {
     630       148260 :             TyTy::VariantDef *a = ltype->get_variants ().at (i);
     631       148260 :             TyTy::VariantDef *b = type.get_variants ().at (i);
     632              : 
     633       148260 :             if (a->num_fields () != b->num_fields ())
     634              :               {
     635            0 :                 return unify_error_type_node ();
     636              :               }
     637              : 
     638       256878 :             for (size_t j = 0; j < a->num_fields (); j++)
     639              :               {
     640       149539 :                 TyTy::StructFieldType *base_field = a->get_field_at_index (j);
     641       149539 :                 TyTy::StructFieldType *other_field = b->get_field_at_index (j);
     642              : 
     643       149539 :                 TyTy::BaseType *this_field_ty = base_field->get_field_type ();
     644       149539 :                 TyTy::BaseType *other_field_ty = other_field->get_field_type ();
     645              : 
     646       149539 :                 TyTy::BaseType *unified_ty
     647       149539 :                   = resolve_subtype (TyTy::TyWithLocation (this_field_ty),
     648       149539 :                                      TyTy::TyWithLocation (other_field_ty));
     649       149539 :                 if (unified_ty->get_kind () == TyTy::TypeKind::ERROR)
     650              :                   {
     651        40921 :                     return unify_error_type_node ();
     652              :                   }
     653              :               }
     654              :           }
     655              : 
     656              :         // generic args for the unit-struct case
     657        97542 :         if (type.is_unit () && ltype->is_unit ())
     658              :           {
     659        32094 :             rust_assert (type.get_num_substitutions ()
     660              :                          == ltype->get_num_substitutions ());
     661              : 
     662        32746 :             for (size_t i = 0; i < type.get_num_substitutions (); i++)
     663              :               {
     664          708 :                 auto &a = ltype->get_substs ().at (i);
     665          708 :                 auto &b = type.get_substs ().at (i);
     666              : 
     667          708 :                 auto pa = a.get_param_ty ();
     668          708 :                 auto pb = b.get_param_ty ();
     669              : 
     670          708 :                 auto res = resolve_subtype (TyTy::TyWithLocation (pa),
     671          708 :                                             TyTy::TyWithLocation (pb));
     672          708 :                 if (res->get_kind () == TyTy::TypeKind::ERROR)
     673              :                   {
     674           56 :                     return unify_error_type_node ();
     675              :                   }
     676              :               }
     677              :           }
     678              : 
     679              :         return ltype;
     680       138467 :       }
     681       545336 :       break;
     682              : 
     683       545336 :     case TyTy::STR:
     684       545336 :     case TyTy::REF:
     685       545336 :     case TyTy::POINTER:
     686       545336 :     case TyTy::PARAM:
     687       545336 :     case TyTy::ARRAY:
     688       545336 :     case TyTy::SLICE:
     689       545336 :     case TyTy::FNDEF:
     690       545336 :     case TyTy::FNPTR:
     691       545336 :     case TyTy::TUPLE:
     692       545336 :     case TyTy::BOOL:
     693       545336 :     case TyTy::CHAR:
     694       545336 :     case TyTy::INT:
     695       545336 :     case TyTy::UINT:
     696       545336 :     case TyTy::FLOAT:
     697       545336 :     case TyTy::USIZE:
     698       545336 :     case TyTy::ISIZE:
     699       545336 :     case TyTy::NEVER:
     700       545336 :     case TyTy::PLACEHOLDER:
     701       545336 :     case TyTy::PROJECTION:
     702       545336 :     case TyTy::DYNAMIC:
     703       545336 :     case TyTy::CLOSURE:
     704       545336 :     case TyTy::OPAQUE:
     705       545336 :     case TyTy::CONST:
     706       545336 :     case TyTy::ERROR:
     707       545336 :       return unify_error_type_node ();
     708              :     }
     709        91791 :   return unify_error_type_node ();
     710              : }
     711              : 
     712              : TyTy::BaseType *
     713         7396 : UnifyRules::expect_str (TyTy::StrType *ltype, TyTy::BaseType *rtype)
     714              : {
     715         7396 :   switch (rtype->get_kind ())
     716              :     {
     717            0 :     case TyTy::INFER:
     718            0 :       {
     719            0 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
     720            0 :         bool is_valid
     721            0 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
     722            0 :         if (is_valid)
     723              :           return ltype;
     724              :       }
     725              :       break;
     726              : 
     727              :     case TyTy::STR:
     728              :       return rtype;
     729              : 
     730           91 :     case TyTy::ADT:
     731           91 :     case TyTy::REF:
     732           91 :     case TyTy::POINTER:
     733           91 :     case TyTy::PARAM:
     734           91 :     case TyTy::ARRAY:
     735           91 :     case TyTy::SLICE:
     736           91 :     case TyTy::FNDEF:
     737           91 :     case TyTy::FNPTR:
     738           91 :     case TyTy::TUPLE:
     739           91 :     case TyTy::BOOL:
     740           91 :     case TyTy::CHAR:
     741           91 :     case TyTy::INT:
     742           91 :     case TyTy::UINT:
     743           91 :     case TyTy::FLOAT:
     744           91 :     case TyTy::USIZE:
     745           91 :     case TyTy::ISIZE:
     746           91 :     case TyTy::NEVER:
     747           91 :     case TyTy::PLACEHOLDER:
     748           91 :     case TyTy::PROJECTION:
     749           91 :     case TyTy::DYNAMIC:
     750           91 :     case TyTy::CLOSURE:
     751           91 :     case TyTy::OPAQUE:
     752           91 :     case TyTy::CONST:
     753           91 :     case TyTy::ERROR:
     754           91 :       return unify_error_type_node ();
     755              :     }
     756            0 :   return unify_error_type_node ();
     757              : }
     758              : 
     759              : TyTy::BaseType *
     760      2502280 : UnifyRules::expect_reference (TyTy::ReferenceType *ltype, TyTy::BaseType *rtype)
     761              : {
     762      2502280 :   switch (rtype->get_kind ())
     763              :     {
     764          159 :     case TyTy::INFER:
     765          159 :       {
     766          159 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
     767          159 :         bool is_valid
     768          159 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
     769          159 :         if (is_valid)
     770              :           return ltype;
     771              :       }
     772              :       break;
     773              : 
     774       118483 :     case TyTy::REF:
     775       118483 :       {
     776       118483 :         TyTy::ReferenceType &type = *static_cast<TyTy::ReferenceType *> (rtype);
     777       118483 :         auto base_type = ltype->get_base ();
     778       118483 :         auto other_base_type = type.get_base ();
     779              : 
     780       118483 :         TyTy::BaseType *base_resolved
     781       118483 :           = resolve_subtype (TyTy::TyWithLocation (base_type),
     782       118483 :                              TyTy::TyWithLocation (other_base_type));
     783       118483 :         if (base_resolved->get_kind () == TyTy::TypeKind::ERROR)
     784              :           {
     785        47056 :             return unify_error_type_node ();
     786              :           }
     787              : 
     788              :         // rust is permissive about mutablity here you can always go from
     789              :         // mutable to immutable but not the otherway round
     790        71427 :         bool mutability_ok = ltype->is_mutable () ? type.is_mutable () : true;
     791         1431 :         if (!mutability_ok)
     792              :           {
     793           13 :             return unify_error_type_node ();
     794              :           }
     795              : 
     796              :         return ltype;
     797              :       }
     798      2383638 :       break;
     799              : 
     800      2383638 :     case TyTy::STR:
     801      2383638 :     case TyTy::ADT:
     802      2383638 :     case TyTy::POINTER:
     803      2383638 :     case TyTy::PARAM:
     804      2383638 :     case TyTy::ARRAY:
     805      2383638 :     case TyTy::SLICE:
     806      2383638 :     case TyTy::FNDEF:
     807      2383638 :     case TyTy::FNPTR:
     808      2383638 :     case TyTy::TUPLE:
     809      2383638 :     case TyTy::BOOL:
     810      2383638 :     case TyTy::CHAR:
     811      2383638 :     case TyTy::INT:
     812      2383638 :     case TyTy::UINT:
     813      2383638 :     case TyTy::FLOAT:
     814      2383638 :     case TyTy::USIZE:
     815      2383638 :     case TyTy::ISIZE:
     816      2383638 :     case TyTy::NEVER:
     817      2383638 :     case TyTy::PLACEHOLDER:
     818      2383638 :     case TyTy::PROJECTION:
     819      2383638 :     case TyTy::DYNAMIC:
     820      2383638 :     case TyTy::CLOSURE:
     821      2383638 :     case TyTy::OPAQUE:
     822      2383638 :     case TyTy::CONST:
     823      2383638 :     case TyTy::ERROR:
     824      2383638 :       return unify_error_type_node ();
     825              :     }
     826            7 :   return unify_error_type_node ();
     827              : }
     828              : 
     829              : TyTy::BaseType *
     830        19462 : UnifyRules::expect_pointer (TyTy::PointerType *ltype, TyTy::BaseType *rtype)
     831              : {
     832        19462 :   switch (rtype->get_kind ())
     833              :     {
     834            0 :     case TyTy::INFER:
     835            0 :       {
     836            0 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
     837            0 :         bool is_valid
     838            0 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
     839            0 :         if (is_valid)
     840              :           return ltype;
     841              :       }
     842              :       break;
     843              : 
     844        18229 :     case TyTy::POINTER:
     845        18229 :       {
     846        18229 :         TyTy::PointerType &type = *static_cast<TyTy::PointerType *> (rtype);
     847        18229 :         auto base_type = ltype->get_base ();
     848        18229 :         auto other_base_type = type.get_base ();
     849              : 
     850        18229 :         TyTy::BaseType *base_resolved
     851        18229 :           = resolve_subtype (TyTy::TyWithLocation (base_type),
     852        18229 :                              TyTy::TyWithLocation (other_base_type));
     853        18229 :         if (base_resolved->get_kind () == TyTy::TypeKind::ERROR)
     854              :           {
     855          167 :             return unify_error_type_node ();
     856              :           }
     857              : 
     858              :         // rust is permissive about mutablity here you can always go from
     859              :         // mutable to immutable but not the otherway round
     860        18062 :         bool mutability_ok = ltype->is_mutable () ? type.is_mutable () : true;
     861         3339 :         if (!mutability_ok)
     862              :           {
     863           36 :             return unify_error_type_node ();
     864              :           }
     865              : 
     866              :         return ltype;
     867              :       }
     868         1233 :       break;
     869              : 
     870         1233 :     case TyTy::STR:
     871         1233 :     case TyTy::ADT:
     872         1233 :     case TyTy::REF:
     873         1233 :     case TyTy::PARAM:
     874         1233 :     case TyTy::ARRAY:
     875         1233 :     case TyTy::SLICE:
     876         1233 :     case TyTy::FNDEF:
     877         1233 :     case TyTy::FNPTR:
     878         1233 :     case TyTy::TUPLE:
     879         1233 :     case TyTy::BOOL:
     880         1233 :     case TyTy::CHAR:
     881         1233 :     case TyTy::INT:
     882         1233 :     case TyTy::UINT:
     883         1233 :     case TyTy::FLOAT:
     884         1233 :     case TyTy::USIZE:
     885         1233 :     case TyTy::ISIZE:
     886         1233 :     case TyTy::NEVER:
     887         1233 :     case TyTy::PLACEHOLDER:
     888         1233 :     case TyTy::PROJECTION:
     889         1233 :     case TyTy::DYNAMIC:
     890         1233 :     case TyTy::CLOSURE:
     891         1233 :     case TyTy::OPAQUE:
     892         1233 :     case TyTy::CONST:
     893         1233 :     case TyTy::ERROR:
     894         1233 :       return unify_error_type_node ();
     895              :     }
     896            0 :   return unify_error_type_node ();
     897              : }
     898              : 
     899              : TyTy::BaseType *
     900        20066 : UnifyRules::expect_param (TyTy::ParamType *ltype, TyTy::BaseType *rtype)
     901              : {
     902        20066 :   switch (rtype->get_kind ())
     903              :     {
     904          512 :     case TyTy::INFER:
     905          512 :       {
     906          512 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
     907          512 :         bool is_valid
     908          512 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
     909          512 :         if (is_valid)
     910              :           return ltype;
     911              :       }
     912              :       break;
     913              : 
     914        19432 :     case TyTy::PARAM:
     915        19432 :       {
     916        19432 :         TyTy::ParamType &type = *static_cast<TyTy::ParamType *> (rtype);
     917              :         // bool symbol_matches
     918              :         //   = ltype->get_symbol ().compare (type.get_symbol ()) == 0;
     919              :         // // TODO
     920              :         // // I think rustc checks a debruinj index
     921              :         // if (symbol_matches)
     922              :         //   {
     923              :         //     return type.clone ();
     924              :         //   }
     925              : 
     926              :         // matching symbol is not going to work when we mix symbol's and have
     927              :         // nested generics
     928              : 
     929              :         // bounds match? FIXME
     930              : 
     931        19432 :         return type.clone ();
     932              :       }
     933          122 :       break;
     934              : 
     935          122 :     case TyTy::POINTER:
     936          122 :     case TyTy::STR:
     937          122 :     case TyTy::ADT:
     938          122 :     case TyTy::REF:
     939          122 :     case TyTy::ARRAY:
     940          122 :     case TyTy::SLICE:
     941          122 :     case TyTy::FNDEF:
     942          122 :     case TyTy::FNPTR:
     943          122 :     case TyTy::TUPLE:
     944          122 :     case TyTy::BOOL:
     945          122 :     case TyTy::CHAR:
     946          122 :     case TyTy::INT:
     947          122 :     case TyTy::UINT:
     948          122 :     case TyTy::FLOAT:
     949          122 :     case TyTy::USIZE:
     950          122 :     case TyTy::ISIZE:
     951          122 :     case TyTy::NEVER:
     952          122 :     case TyTy::PLACEHOLDER:
     953          122 :     case TyTy::PROJECTION:
     954          122 :     case TyTy::DYNAMIC:
     955          122 :     case TyTy::CLOSURE:
     956          122 :     case TyTy::OPAQUE:
     957          122 :     case TyTy::CONST:
     958          122 :     case TyTy::ERROR:
     959          122 :       return unify_error_type_node ();
     960              :     }
     961            0 :   return unify_error_type_node ();
     962              : }
     963              : 
     964              : TyTy::BaseType *
     965         2181 : UnifyRules::expect_array (TyTy::ArrayType *ltype, TyTy::BaseType *rtype)
     966              : {
     967         2181 :   switch (rtype->get_kind ())
     968              :     {
     969           15 :     case TyTy::INFER:
     970           15 :       {
     971           15 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
     972           15 :         bool is_valid
     973           15 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
     974           15 :         if (is_valid)
     975              :           return ltype;
     976              :       }
     977              :       break;
     978              : 
     979         1649 :     case TyTy::ARRAY:
     980         1649 :       {
     981         1649 :         TyTy::ArrayType &type = *static_cast<TyTy::ArrayType *> (rtype);
     982         1649 :         TyTy::BaseType *element_unify
     983         1649 :           = resolve_subtype (TyTy::TyWithLocation (ltype->get_element_type ()),
     984         1649 :                              TyTy::TyWithLocation (type.get_element_type ()));
     985              : 
     986         1649 :         if (element_unify->get_kind () == TyTy::TypeKind::ERROR)
     987            0 :           return unify_error_type_node ();
     988              : 
     989         1649 :         auto ltype_cap = ltype->get_capacity ();
     990         1649 :         auto rtype_cap = type.get_capacity ();
     991              : 
     992              :         // If either capacity is not a const type, return error
     993         1649 :         if (ltype_cap->get_kind () != TyTy::TypeKind::CONST
     994         1649 :             || rtype_cap->get_kind () != TyTy::TypeKind::CONST)
     995            0 :           return unify_error_type_node ();
     996              : 
     997         1649 :         bool save_emit_error = emit_error;
     998         1649 :         emit_error = false;
     999         1649 :         TyTy::BaseType *capacity_unify
    1000         1649 :           = resolve_subtype (TyTy::TyWithLocation (ltype_cap),
    1001         1649 :                              TyTy::TyWithLocation (rtype_cap));
    1002         1649 :         emit_error = save_emit_error;
    1003              : 
    1004         1649 :         if (capacity_unify->get_kind () != TyTy::TypeKind::CONST)
    1005           19 :           return unify_error_type_node ();
    1006              : 
    1007         1630 :         auto capacity_type_unify = capacity_unify->as_const_type ();
    1008         1630 :         if (capacity_type_unify->const_kind ()
    1009              :             == TyTy::BaseConstType::ConstKind::Error)
    1010              :           {
    1011            4 :             emit_error = false;
    1012            4 :             return unify_error_type_node ();
    1013              :           }
    1014              : 
    1015         1626 :         return new TyTy::ArrayType (
    1016         1626 :           type.get_ref (), type.get_ty_ref (), type.get_ident ().locus,
    1017         1626 :           TyTy::TyVar (capacity_type_unify->as_base_type ()->get_ref ()),
    1018         3252 :           TyTy::TyVar (element_unify->get_ref ()));
    1019              :       }
    1020          517 :       break;
    1021              : 
    1022          517 :     case TyTy::PARAM:
    1023          517 :     case TyTy::POINTER:
    1024          517 :     case TyTy::STR:
    1025          517 :     case TyTy::ADT:
    1026          517 :     case TyTy::REF:
    1027          517 :     case TyTy::SLICE:
    1028          517 :     case TyTy::FNDEF:
    1029          517 :     case TyTy::FNPTR:
    1030          517 :     case TyTy::TUPLE:
    1031          517 :     case TyTy::BOOL:
    1032          517 :     case TyTy::CHAR:
    1033          517 :     case TyTy::INT:
    1034          517 :     case TyTy::UINT:
    1035          517 :     case TyTy::FLOAT:
    1036          517 :     case TyTy::USIZE:
    1037          517 :     case TyTy::ISIZE:
    1038          517 :     case TyTy::NEVER:
    1039          517 :     case TyTy::PLACEHOLDER:
    1040          517 :     case TyTy::PROJECTION:
    1041          517 :     case TyTy::DYNAMIC:
    1042          517 :     case TyTy::CLOSURE:
    1043          517 :     case TyTy::OPAQUE:
    1044          517 :     case TyTy::CONST:
    1045          517 :     case TyTy::ERROR:
    1046          517 :       return unify_error_type_node ();
    1047              :     }
    1048            0 :   return unify_error_type_node ();
    1049              : }
    1050              : 
    1051              : TyTy::BaseType *
    1052         2814 : UnifyRules::expect_slice (TyTy::SliceType *ltype, TyTy::BaseType *rtype)
    1053              : {
    1054         2814 :   switch (rtype->get_kind ())
    1055              :     {
    1056            0 :     case TyTy::INFER:
    1057            0 :       {
    1058            0 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1059            0 :         bool is_valid
    1060            0 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1061            0 :         if (is_valid)
    1062              :           return ltype;
    1063              :       }
    1064              :       break;
    1065              : 
    1066         2223 :     case TyTy::SLICE:
    1067         2223 :       {
    1068         2223 :         TyTy::SliceType &type = *static_cast<TyTy::SliceType *> (rtype);
    1069         2223 :         TyTy::BaseType *element_unify
    1070         2223 :           = resolve_subtype (TyTy::TyWithLocation (ltype->get_element_type ()),
    1071         2223 :                              TyTy::TyWithLocation (type.get_element_type ()));
    1072              : 
    1073         2223 :         if (element_unify->get_kind () != TyTy::TypeKind::ERROR)
    1074              :           return ltype;
    1075              :       }
    1076              :       break;
    1077              : 
    1078          591 :     case TyTy::PARAM:
    1079          591 :     case TyTy::POINTER:
    1080          591 :     case TyTy::STR:
    1081          591 :     case TyTy::ADT:
    1082          591 :     case TyTy::REF:
    1083          591 :     case TyTy::ARRAY:
    1084          591 :     case TyTy::FNDEF:
    1085          591 :     case TyTy::FNPTR:
    1086          591 :     case TyTy::TUPLE:
    1087          591 :     case TyTy::BOOL:
    1088          591 :     case TyTy::CHAR:
    1089          591 :     case TyTy::INT:
    1090          591 :     case TyTy::UINT:
    1091          591 :     case TyTy::FLOAT:
    1092          591 :     case TyTy::USIZE:
    1093          591 :     case TyTy::ISIZE:
    1094          591 :     case TyTy::NEVER:
    1095          591 :     case TyTy::PLACEHOLDER:
    1096          591 :     case TyTy::PROJECTION:
    1097          591 :     case TyTy::DYNAMIC:
    1098          591 :     case TyTy::CLOSURE:
    1099          591 :     case TyTy::OPAQUE:
    1100          591 :     case TyTy::CONST:
    1101          591 :     case TyTy::ERROR:
    1102          591 :       return unify_error_type_node ();
    1103              :     }
    1104            0 :   return unify_error_type_node ();
    1105              : }
    1106              : 
    1107              : TyTy::BaseType *
    1108         6934 : UnifyRules::expect_fndef (TyTy::FnType *ltype, TyTy::BaseType *rtype)
    1109              : {
    1110         6934 :   switch (rtype->get_kind ())
    1111              :     {
    1112            0 :     case TyTy::INFER:
    1113            0 :       {
    1114            0 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1115            0 :         bool is_valid
    1116            0 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1117            0 :         if (is_valid)
    1118              :           return ltype;
    1119              :       }
    1120              :       break;
    1121              : 
    1122         6934 :     case TyTy::FNDEF:
    1123         6934 :       {
    1124         6934 :         TyTy::FnType &type = *static_cast<TyTy::FnType *> (rtype);
    1125         6934 :         if (ltype->num_params () != type.num_params ())
    1126              :           {
    1127            0 :             return unify_error_type_node ();
    1128              :           }
    1129              : 
    1130        17197 :         for (size_t i = 0; i < ltype->num_params (); i++)
    1131              :           {
    1132        10269 :             auto a = ltype->param_at (i).get_type ();
    1133        10269 :             auto b = type.param_at (i).get_type ();
    1134              : 
    1135        10269 :             auto unified_param = resolve_subtype (TyTy::TyWithLocation (a),
    1136        10269 :                                                   TyTy::TyWithLocation (b));
    1137        10269 :             if (unified_param->get_kind () == TyTy::TypeKind::ERROR)
    1138              :               {
    1139            6 :                 return unify_error_type_node ();
    1140              :               }
    1141              :           }
    1142              : 
    1143         6928 :         auto unified_return
    1144         6928 :           = resolve_subtype (TyTy::TyWithLocation (ltype->get_return_type ()),
    1145         6928 :                              TyTy::TyWithLocation (type.get_return_type ()));
    1146         6921 :         if (unified_return->get_kind () == TyTy::TypeKind::ERROR)
    1147              :           {
    1148            1 :             return unify_error_type_node ();
    1149              :           }
    1150              : 
    1151              :         // ABI match? see
    1152              :         // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/extern.20blocks/near/346416045
    1153         6920 :         if (ltype->get_abi () != type.get_abi ())
    1154              :           {
    1155            0 :             if (emit_error)
    1156              :               {
    1157            0 :                 emit_abi_mismatch (*ltype, type);
    1158              :               }
    1159            0 :             return unify_error_type_node ();
    1160              :           }
    1161              : 
    1162              :         // DEF Id match? see https://github.com/Rust-GCC/gccrs/issues/2053
    1163              : 
    1164              :         return ltype;
    1165              :       }
    1166            0 :       break;
    1167              : 
    1168            0 :     case TyTy::TUPLE:
    1169            0 :     case TyTy::BOOL:
    1170            0 :     case TyTy::CHAR:
    1171            0 :     case TyTy::INT:
    1172            0 :     case TyTy::FLOAT:
    1173            0 :     case TyTy::ISIZE:
    1174            0 :     case TyTy::ADT:
    1175            0 :     case TyTy::STR:
    1176            0 :     case TyTy::REF:
    1177            0 :     case TyTy::POINTER:
    1178            0 :     case TyTy::PARAM:
    1179            0 :     case TyTy::ARRAY:
    1180            0 :     case TyTy::SLICE:
    1181            0 :     case TyTy::FNPTR:
    1182            0 :     case TyTy::UINT:
    1183            0 :     case TyTy::USIZE:
    1184            0 :     case TyTy::NEVER:
    1185            0 :     case TyTy::PLACEHOLDER:
    1186            0 :     case TyTy::PROJECTION:
    1187            0 :     case TyTy::DYNAMIC:
    1188            0 :     case TyTy::CLOSURE:
    1189            0 :     case TyTy::OPAQUE:
    1190            0 :     case TyTy::CONST:
    1191            0 :     case TyTy::ERROR:
    1192            0 :       return unify_error_type_node ();
    1193              :     }
    1194            0 :   return unify_error_type_node ();
    1195              : }
    1196              : 
    1197              : TyTy::BaseType *
    1198         4966 : UnifyRules::expect_fnptr (TyTy::FnPtr *ltype, TyTy::BaseType *rtype)
    1199              : {
    1200         4966 :   switch (rtype->get_kind ())
    1201              :     {
    1202            1 :     case TyTy::INFER:
    1203            1 :       {
    1204            1 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1205            1 :         bool is_valid
    1206            1 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1207            1 :         if (is_valid)
    1208              :           return ltype;
    1209              :       }
    1210              :       break;
    1211              : 
    1212          123 :     case TyTy::FNPTR:
    1213          123 :       {
    1214          123 :         TyTy::FnPtr &type = *static_cast<TyTy::FnPtr *> (rtype);
    1215          123 :         if (ltype->num_params () != type.num_params ())
    1216              :           {
    1217            0 :             return unify_error_type_node ();
    1218              :           }
    1219              : 
    1220          173 :         for (size_t i = 0; i < ltype->num_params (); i++)
    1221              :           {
    1222           50 :             auto a = ltype->get_param_type_at (i);
    1223           50 :             auto b = type.get_param_type_at (i);
    1224              : 
    1225           50 :             auto unified_param = resolve_subtype (TyTy::TyWithLocation (a),
    1226           50 :                                                   TyTy::TyWithLocation (b));
    1227           50 :             if (unified_param->get_kind () == TyTy::TypeKind::ERROR)
    1228              :               {
    1229            0 :                 return unify_error_type_node ();
    1230              :               }
    1231              :           }
    1232              : 
    1233          123 :         auto unified_return
    1234          123 :           = resolve_subtype (TyTy::TyWithLocation (ltype->get_return_type ()),
    1235          123 :                              TyTy::TyWithLocation (type.get_return_type ()));
    1236          123 :         if (unified_return->get_kind () == TyTy::TypeKind::ERROR)
    1237              :           {
    1238            0 :             return unify_error_type_node ();
    1239              :           }
    1240              : 
    1241          123 :         if (ltype->get_abi () != type.get_abi ())
    1242              :           {
    1243           24 :             return unify_error_type_node ();
    1244              :           }
    1245              : 
    1246           99 :         if (ltype->get_unsafety () != type.get_unsafety ())
    1247              :           {
    1248           12 :             return unify_error_type_node ();
    1249              :           }
    1250              : 
    1251              :         return ltype;
    1252              :       }
    1253           38 :       break;
    1254              : 
    1255           38 :     case TyTy::FNDEF:
    1256           38 :       {
    1257           38 :         TyTy::FnType &type = *static_cast<TyTy::FnType *> (rtype);
    1258           38 :         auto this_ret_type = ltype->get_return_type ();
    1259           38 :         auto other_ret_type = type.get_return_type ();
    1260              : 
    1261           38 :         auto unified_result
    1262           38 :           = resolve_subtype (TyTy::TyWithLocation (this_ret_type),
    1263           38 :                              TyTy::TyWithLocation (other_ret_type));
    1264           38 :         if (unified_result->get_kind () == TyTy::TypeKind::ERROR)
    1265              :           {
    1266            0 :             return unify_error_type_node ();
    1267              :           }
    1268              : 
    1269           38 :         if (ltype->num_params () != type.num_params ())
    1270              :           {
    1271            0 :             return unify_error_type_node ();
    1272              :           }
    1273              : 
    1274           82 :         for (size_t i = 0; i < ltype->num_params (); i++)
    1275              :           {
    1276           44 :             auto this_param = ltype->get_param_type_at (i);
    1277           44 :             auto other_param = type.param_at (i).get_type ();
    1278              : 
    1279           44 :             auto unified_param
    1280           44 :               = resolve_subtype (TyTy::TyWithLocation (this_param),
    1281           44 :                                  TyTy::TyWithLocation (other_param));
    1282           44 :             if (unified_param->get_kind () == TyTy::TypeKind::ERROR)
    1283              :               {
    1284            0 :                 return unify_error_type_node ();
    1285              :               }
    1286              :           }
    1287              : 
    1288              :         // FIXME
    1289              :         //
    1290              :         // there is a bug in:
    1291              :         // testsuite/rust/compile/try-catch-unwind-{new,old}.rs I think the test
    1292              :         //
    1293              :         // case is wrong because it should be taking an FnOnce which probably
    1294              :         // didnt exist at the time in gccrs
    1295              :         //
    1296              :         // if (ltype->get_abi () != type.get_abi ())
    1297              :         //   {
    1298              :         //     return unify_error_type_node ();
    1299              :         //   }
    1300              : 
    1301              :         // FIXME fntype needs to track unsafe or not
    1302              :         // if (ltype->get_unsafety () != type.get_unsafety ())
    1303              :         //   {
    1304              :         //     return unify_error_type_node ();
    1305              :         //   }
    1306              : 
    1307              :         return ltype;
    1308              :       }
    1309            0 :       break;
    1310              : 
    1311            0 :     case TyTy::CLOSURE:
    1312            0 :       {
    1313            0 :         TyTy::ClosureType &type = *static_cast<TyTy::ClosureType *> (rtype);
    1314            0 :         auto this_ret_type = ltype->get_return_type ();
    1315            0 :         auto other_ret_type = type.get_return_type ();
    1316              : 
    1317            0 :         auto unified_result
    1318            0 :           = resolve_subtype (TyTy::TyWithLocation (this_ret_type),
    1319            0 :                              TyTy::TyWithLocation (other_ret_type));
    1320            0 :         if (unified_result->get_kind () == TyTy::TypeKind::ERROR)
    1321              :           {
    1322            0 :             return unify_error_type_node ();
    1323              :           }
    1324              : 
    1325            0 :         if (ltype->num_params () != type.get_num_params ())
    1326              :           {
    1327            0 :             return unify_error_type_node ();
    1328              :           }
    1329              : 
    1330            0 :         for (size_t i = 0; i < ltype->num_params (); i++)
    1331              :           {
    1332            0 :             auto this_param = ltype->get_param_type_at (i);
    1333            0 :             auto other_param = type.get_param_type_at (i);
    1334              : 
    1335            0 :             auto unified_param
    1336            0 :               = resolve_subtype (TyTy::TyWithLocation (this_param),
    1337            0 :                                  TyTy::TyWithLocation (other_param));
    1338            0 :             if (unified_param->get_kind () == TyTy::TypeKind::ERROR)
    1339              :               {
    1340            0 :                 return unify_error_type_node ();
    1341              :               }
    1342              :           }
    1343              : 
    1344              :         return ltype;
    1345              :       }
    1346         4804 :       break;
    1347              : 
    1348         4804 :     case TyTy::TUPLE:
    1349         4804 :     case TyTy::BOOL:
    1350         4804 :     case TyTy::CHAR:
    1351         4804 :     case TyTy::INT:
    1352         4804 :     case TyTy::FLOAT:
    1353         4804 :     case TyTy::ISIZE:
    1354         4804 :     case TyTy::ADT:
    1355         4804 :     case TyTy::STR:
    1356         4804 :     case TyTy::REF:
    1357         4804 :     case TyTy::POINTER:
    1358         4804 :     case TyTy::PARAM:
    1359         4804 :     case TyTy::ARRAY:
    1360         4804 :     case TyTy::SLICE:
    1361         4804 :     case TyTy::UINT:
    1362         4804 :     case TyTy::USIZE:
    1363         4804 :     case TyTy::NEVER:
    1364         4804 :     case TyTy::PLACEHOLDER:
    1365         4804 :     case TyTy::PROJECTION:
    1366         4804 :     case TyTy::DYNAMIC:
    1367         4804 :     case TyTy::OPAQUE:
    1368         4804 :     case TyTy::CONST:
    1369         4804 :     case TyTy::ERROR:
    1370         4804 :       return unify_error_type_node ();
    1371              :     }
    1372            0 :   return unify_error_type_node ();
    1373              : }
    1374              : 
    1375              : TyTy::BaseType *
    1376        16341 : UnifyRules::expect_tuple (TyTy::TupleType *ltype, TyTy::BaseType *rtype)
    1377              : {
    1378        16341 :   switch (rtype->get_kind ())
    1379              :     {
    1380           24 :     case TyTy::INFER:
    1381           24 :       {
    1382           24 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1383           24 :         bool is_valid
    1384           24 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1385           24 :         if (is_valid)
    1386              :           return ltype;
    1387              :       }
    1388              :       break;
    1389              : 
    1390        15421 :     case TyTy::TUPLE:
    1391        15421 :       {
    1392        15421 :         TyTy::TupleType &type = *static_cast<TyTy::TupleType *> (rtype);
    1393        15421 :         if (ltype->num_fields () != type.num_fields ())
    1394              :           {
    1395            2 :             return unify_error_type_node ();
    1396              :           }
    1397              : 
    1398        15419 :         std::vector<TyTy::TyVar> fields;
    1399        17733 :         for (size_t i = 0; i < ltype->num_fields (); i++)
    1400              :           {
    1401         2328 :             TyTy::BaseType *bo = ltype->get_field (i);
    1402         2328 :             TyTy::BaseType *fo = type.get_field (i);
    1403              : 
    1404         2328 :             TyTy::BaseType *unified_ty
    1405         2328 :               = resolve_subtype (TyTy::TyWithLocation (bo),
    1406         2328 :                                  TyTy::TyWithLocation (fo));
    1407         2328 :             if (unified_ty->get_kind () == TyTy::TypeKind::ERROR)
    1408           14 :               return unify_error_type_node ();
    1409              : 
    1410         2314 :             fields.emplace_back (unified_ty->get_ref ());
    1411              :           }
    1412              : 
    1413              :         return ltype;
    1414        15419 :       }
    1415          896 :       break;
    1416              : 
    1417          896 :     case TyTy::BOOL:
    1418          896 :     case TyTy::CHAR:
    1419          896 :     case TyTy::INT:
    1420          896 :     case TyTy::FLOAT:
    1421          896 :     case TyTy::ISIZE:
    1422          896 :     case TyTy::ADT:
    1423          896 :     case TyTy::STR:
    1424          896 :     case TyTy::REF:
    1425          896 :     case TyTy::POINTER:
    1426          896 :     case TyTy::PARAM:
    1427          896 :     case TyTy::ARRAY:
    1428          896 :     case TyTy::SLICE:
    1429          896 :     case TyTy::FNDEF:
    1430          896 :     case TyTy::FNPTR:
    1431          896 :     case TyTy::UINT:
    1432          896 :     case TyTy::USIZE:
    1433          896 :     case TyTy::NEVER:
    1434          896 :     case TyTy::PLACEHOLDER:
    1435          896 :     case TyTy::PROJECTION:
    1436          896 :     case TyTy::DYNAMIC:
    1437          896 :     case TyTy::CLOSURE:
    1438          896 :     case TyTy::OPAQUE:
    1439          896 :     case TyTy::CONST:
    1440          896 :     case TyTy::ERROR:
    1441          896 :       return unify_error_type_node ();
    1442              :     }
    1443            6 :   return unify_error_type_node ();
    1444              : }
    1445              : 
    1446              : TyTy::BaseType *
    1447        23311 : UnifyRules::expect_bool (TyTy::BoolType *ltype, TyTy::BaseType *rtype)
    1448              : {
    1449        23311 :   switch (rtype->get_kind ())
    1450              :     {
    1451          143 :     case TyTy::INFER:
    1452          143 :       {
    1453          143 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1454          143 :         bool is_valid
    1455          143 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1456          143 :         if (is_valid)
    1457              :           {
    1458           42 :             if (commit_flag)
    1459            0 :               r->apply_primitive_type_hint (*ltype);
    1460              :             return ltype;
    1461              :           }
    1462              :       }
    1463              :       break;
    1464              : 
    1465              :     case TyTy::BOOL:
    1466              :       return rtype;
    1467              : 
    1468         8157 :     case TyTy::CHAR:
    1469         8157 :     case TyTy::INT:
    1470         8157 :     case TyTy::FLOAT:
    1471         8157 :     case TyTy::ISIZE:
    1472         8157 :     case TyTy::ADT:
    1473         8157 :     case TyTy::STR:
    1474         8157 :     case TyTy::REF:
    1475         8157 :     case TyTy::POINTER:
    1476         8157 :     case TyTy::PARAM:
    1477         8157 :     case TyTy::ARRAY:
    1478         8157 :     case TyTy::SLICE:
    1479         8157 :     case TyTy::FNDEF:
    1480         8157 :     case TyTy::FNPTR:
    1481         8157 :     case TyTy::TUPLE:
    1482         8157 :     case TyTy::UINT:
    1483         8157 :     case TyTy::USIZE:
    1484         8157 :     case TyTy::NEVER:
    1485         8157 :     case TyTy::PLACEHOLDER:
    1486         8157 :     case TyTy::PROJECTION:
    1487         8157 :     case TyTy::DYNAMIC:
    1488         8157 :     case TyTy::CLOSURE:
    1489         8157 :     case TyTy::OPAQUE:
    1490         8157 :     case TyTy::CONST:
    1491         8157 :     case TyTy::ERROR:
    1492         8157 :       return unify_error_type_node ();
    1493              :     }
    1494          101 :   return unify_error_type_node ();
    1495              : }
    1496              : 
    1497              : TyTy::BaseType *
    1498         3158 : UnifyRules::expect_char (TyTy::CharType *ltype, TyTy::BaseType *rtype)
    1499              : {
    1500         3158 :   switch (rtype->get_kind ())
    1501              :     {
    1502           25 :     case TyTy::INFER:
    1503           25 :       {
    1504           25 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1505           25 :         bool is_valid
    1506           25 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1507           25 :         if (is_valid)
    1508              :           {
    1509           21 :             if (commit_flag)
    1510            0 :               r->apply_primitive_type_hint (*ltype);
    1511              :             return ltype;
    1512              :           }
    1513              :       }
    1514              :       break;
    1515              : 
    1516              :     case TyTy::CHAR:
    1517              :       return rtype;
    1518              : 
    1519         1840 :     case TyTy::INT:
    1520         1840 :     case TyTy::FLOAT:
    1521         1840 :     case TyTy::ISIZE:
    1522         1840 :     case TyTy::ADT:
    1523         1840 :     case TyTy::STR:
    1524         1840 :     case TyTy::REF:
    1525         1840 :     case TyTy::POINTER:
    1526         1840 :     case TyTy::PARAM:
    1527         1840 :     case TyTy::ARRAY:
    1528         1840 :     case TyTy::SLICE:
    1529         1840 :     case TyTy::FNDEF:
    1530         1840 :     case TyTy::FNPTR:
    1531         1840 :     case TyTy::TUPLE:
    1532         1840 :     case TyTy::BOOL:
    1533         1840 :     case TyTy::UINT:
    1534         1840 :     case TyTy::USIZE:
    1535         1840 :     case TyTy::NEVER:
    1536         1840 :     case TyTy::PLACEHOLDER:
    1537         1840 :     case TyTy::PROJECTION:
    1538         1840 :     case TyTy::DYNAMIC:
    1539         1840 :     case TyTy::CLOSURE:
    1540         1840 :     case TyTy::OPAQUE:
    1541         1840 :     case TyTy::CONST:
    1542         1840 :     case TyTy::ERROR:
    1543         1840 :       return unify_error_type_node ();
    1544              :     }
    1545            4 :   return unify_error_type_node ();
    1546              : }
    1547              : 
    1548              : TyTy::BaseType *
    1549      1813357 : UnifyRules::expect_int (TyTy::IntType *ltype, TyTy::BaseType *rtype)
    1550              : {
    1551      1813357 :   switch (rtype->get_kind ())
    1552              :     {
    1553       134821 :     case TyTy::INFER:
    1554       134821 :       {
    1555       134821 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1556       134821 :         bool is_valid
    1557       134821 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL
    1558       134821 :             || r->get_infer_kind () == TyTy::InferType::InferTypeKind::INTEGRAL;
    1559              :         if (is_valid)
    1560              :           {
    1561       134817 :             if (commit_flag)
    1562         2576 :               r->apply_primitive_type_hint (*ltype);
    1563              :             return ltype;
    1564              :           }
    1565              :       }
    1566              :       break;
    1567              : 
    1568       158694 :     case TyTy::INT:
    1569       158694 :       {
    1570       158694 :         TyTy::IntType &type = *static_cast<TyTy::IntType *> (rtype);
    1571       158694 :         bool is_valid = ltype->get_int_kind () == type.get_int_kind ();
    1572       158694 :         if (is_valid)
    1573              :           return ltype;
    1574              :       }
    1575              :       break;
    1576              : 
    1577      1519842 :     case TyTy::FLOAT:
    1578      1519842 :     case TyTy::ISIZE:
    1579      1519842 :     case TyTy::ADT:
    1580      1519842 :     case TyTy::STR:
    1581      1519842 :     case TyTy::REF:
    1582      1519842 :     case TyTy::POINTER:
    1583      1519842 :     case TyTy::PARAM:
    1584      1519842 :     case TyTy::ARRAY:
    1585      1519842 :     case TyTy::SLICE:
    1586      1519842 :     case TyTy::FNDEF:
    1587      1519842 :     case TyTy::FNPTR:
    1588      1519842 :     case TyTy::TUPLE:
    1589      1519842 :     case TyTy::BOOL:
    1590      1519842 :     case TyTy::CHAR:
    1591      1519842 :     case TyTy::UINT:
    1592      1519842 :     case TyTy::USIZE:
    1593      1519842 :     case TyTy::NEVER:
    1594      1519842 :     case TyTy::PLACEHOLDER:
    1595      1519842 :     case TyTy::PROJECTION:
    1596      1519842 :     case TyTy::DYNAMIC:
    1597      1519842 :     case TyTy::CLOSURE:
    1598      1519842 :     case TyTy::OPAQUE:
    1599      1519842 :     case TyTy::CONST:
    1600      1519842 :     case TyTy::ERROR:
    1601      1519842 :       return unify_error_type_node ();
    1602              :     }
    1603        69809 :   return unify_error_type_node ();
    1604              : }
    1605              : 
    1606              : TyTy::BaseType *
    1607       471215 : UnifyRules::expect_uint (TyTy::UintType *ltype, TyTy::BaseType *rtype)
    1608              : {
    1609       471215 :   switch (rtype->get_kind ())
    1610              :     {
    1611        88443 :     case TyTy::INFER:
    1612        88443 :       {
    1613        88443 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1614        88443 :         bool is_valid
    1615        88443 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL
    1616        88443 :             || r->get_infer_kind () == TyTy::InferType::InferTypeKind::INTEGRAL;
    1617              :         if (is_valid)
    1618              :           {
    1619        88443 :             if (commit_flag)
    1620         1331 :               r->apply_primitive_type_hint (*ltype);
    1621              :             return ltype;
    1622              :           }
    1623              :       }
    1624              :       break;
    1625              : 
    1626       116170 :     case TyTy::UINT:
    1627       116170 :       {
    1628       116170 :         TyTy::UintType &type = *static_cast<TyTy::UintType *> (rtype);
    1629       116170 :         bool is_valid = ltype->get_uint_kind () == type.get_uint_kind ();
    1630       116170 :         if (is_valid)
    1631              :           return ltype;
    1632              :       }
    1633              :       break;
    1634              : 
    1635       266602 :     case TyTy::FLOAT:
    1636       266602 :     case TyTy::ISIZE:
    1637       266602 :     case TyTy::ADT:
    1638       266602 :     case TyTy::STR:
    1639       266602 :     case TyTy::REF:
    1640       266602 :     case TyTy::POINTER:
    1641       266602 :     case TyTy::PARAM:
    1642       266602 :     case TyTy::ARRAY:
    1643       266602 :     case TyTy::SLICE:
    1644       266602 :     case TyTy::FNDEF:
    1645       266602 :     case TyTy::FNPTR:
    1646       266602 :     case TyTy::TUPLE:
    1647       266602 :     case TyTy::BOOL:
    1648       266602 :     case TyTy::CHAR:
    1649       266602 :     case TyTy::INT:
    1650       266602 :     case TyTy::USIZE:
    1651       266602 :     case TyTy::NEVER:
    1652       266602 :     case TyTy::PLACEHOLDER:
    1653       266602 :     case TyTy::PROJECTION:
    1654       266602 :     case TyTy::DYNAMIC:
    1655       266602 :     case TyTy::CLOSURE:
    1656       266602 :     case TyTy::OPAQUE:
    1657       266602 :     case TyTy::CONST:
    1658       266602 :     case TyTy::ERROR:
    1659       266602 :       return unify_error_type_node ();
    1660              :     }
    1661        53880 :   return unify_error_type_node ();
    1662              : }
    1663              : 
    1664              : TyTy::BaseType *
    1665        76394 : UnifyRules::expect_float (TyTy::FloatType *ltype, TyTy::BaseType *rtype)
    1666              : {
    1667        76394 :   switch (rtype->get_kind ())
    1668              :     {
    1669        29854 :     case TyTy::INFER:
    1670        29854 :       {
    1671        29854 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1672        29854 :         bool is_valid
    1673        29854 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL
    1674        29854 :             || r->get_infer_kind () == TyTy::InferType::InferTypeKind::FLOAT;
    1675              :         if (is_valid)
    1676              :           {
    1677        14280 :             if (commit_flag)
    1678           28 :               r->apply_primitive_type_hint (*ltype);
    1679              :             return ltype;
    1680              :           }
    1681              :       }
    1682              :       break;
    1683              : 
    1684        10861 :     case TyTy::FLOAT:
    1685        10861 :       {
    1686        10861 :         TyTy::FloatType &type = *static_cast<TyTy::FloatType *> (rtype);
    1687        10861 :         bool is_valid = ltype->get_float_kind () == type.get_float_kind ();
    1688        10861 :         if (is_valid)
    1689              :           return ltype;
    1690              :       }
    1691              :       break;
    1692              : 
    1693        35679 :     case TyTy::ISIZE:
    1694        35679 :     case TyTy::ADT:
    1695        35679 :     case TyTy::STR:
    1696        35679 :     case TyTy::REF:
    1697        35679 :     case TyTy::POINTER:
    1698        35679 :     case TyTy::PARAM:
    1699        35679 :     case TyTy::ARRAY:
    1700        35679 :     case TyTy::SLICE:
    1701        35679 :     case TyTy::FNDEF:
    1702        35679 :     case TyTy::FNPTR:
    1703        35679 :     case TyTy::TUPLE:
    1704        35679 :     case TyTy::BOOL:
    1705        35679 :     case TyTy::CHAR:
    1706        35679 :     case TyTy::INT:
    1707        35679 :     case TyTy::UINT:
    1708        35679 :     case TyTy::USIZE:
    1709        35679 :     case TyTy::NEVER:
    1710        35679 :     case TyTy::PLACEHOLDER:
    1711        35679 :     case TyTy::PROJECTION:
    1712        35679 :     case TyTy::DYNAMIC:
    1713        35679 :     case TyTy::CLOSURE:
    1714        35679 :     case TyTy::OPAQUE:
    1715        35679 :     case TyTy::CONST:
    1716        35679 :     case TyTy::ERROR:
    1717        35679 :       return unify_error_type_node ();
    1718              :     }
    1719        17306 :   return unify_error_type_node ();
    1720              : }
    1721              : 
    1722              : TyTy::BaseType *
    1723        93121 : UnifyRules::expect_isize (TyTy::ISizeType *ltype, TyTy::BaseType *rtype)
    1724              : {
    1725        93121 :   switch (rtype->get_kind ())
    1726              :     {
    1727        17387 :     case TyTy::INFER:
    1728        17387 :       {
    1729        17387 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1730        17387 :         bool is_valid
    1731        17387 :           = r->get_infer_kind () != TyTy::InferType::InferTypeKind::FLOAT;
    1732        17387 :         if (is_valid)
    1733              :           {
    1734        17387 :             if (commit_flag)
    1735          345 :               r->apply_primitive_type_hint (*ltype);
    1736              :             return ltype;
    1737              :           }
    1738              :       }
    1739              :       break;
    1740              : 
    1741              :     case TyTy::ISIZE:
    1742              :       return rtype;
    1743              : 
    1744        63895 :     case TyTy::ADT:
    1745        63895 :     case TyTy::STR:
    1746        63895 :     case TyTy::REF:
    1747        63895 :     case TyTy::POINTER:
    1748        63895 :     case TyTy::PARAM:
    1749        63895 :     case TyTy::ARRAY:
    1750        63895 :     case TyTy::SLICE:
    1751        63895 :     case TyTy::FNDEF:
    1752        63895 :     case TyTy::FNPTR:
    1753        63895 :     case TyTy::TUPLE:
    1754        63895 :     case TyTy::BOOL:
    1755        63895 :     case TyTy::CHAR:
    1756        63895 :     case TyTy::INT:
    1757        63895 :     case TyTy::UINT:
    1758        63895 :     case TyTy::FLOAT:
    1759        63895 :     case TyTy::USIZE:
    1760        63895 :     case TyTy::NEVER:
    1761        63895 :     case TyTy::PLACEHOLDER:
    1762        63895 :     case TyTy::PROJECTION:
    1763        63895 :     case TyTy::DYNAMIC:
    1764        63895 :     case TyTy::CLOSURE:
    1765        63895 :     case TyTy::OPAQUE:
    1766        63895 :     case TyTy::CONST:
    1767        63895 :     case TyTy::ERROR:
    1768        63895 :       return unify_error_type_node ();
    1769              :     }
    1770            0 :   return unify_error_type_node ();
    1771              : }
    1772              : 
    1773              : TyTy::BaseType *
    1774       122816 : UnifyRules::expect_usize (TyTy::USizeType *ltype, TyTy::BaseType *rtype)
    1775              : {
    1776       122816 :   switch (rtype->get_kind ())
    1777              :     {
    1778        20591 :     case TyTy::INFER:
    1779        20591 :       {
    1780        20591 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1781        20591 :         bool is_valid
    1782        20591 :           = r->get_infer_kind () != TyTy::InferType::InferTypeKind::FLOAT;
    1783        20591 :         if (is_valid)
    1784              :           {
    1785        20591 :             if (commit_flag)
    1786         1238 :               r->apply_primitive_type_hint (*ltype);
    1787              :             return ltype;
    1788              :           }
    1789              :       }
    1790              :       break;
    1791              : 
    1792              :     case TyTy::USIZE:
    1793              :       return rtype;
    1794              : 
    1795        77500 :     case TyTy::ADT:
    1796        77500 :     case TyTy::STR:
    1797        77500 :     case TyTy::REF:
    1798        77500 :     case TyTy::POINTER:
    1799        77500 :     case TyTy::PARAM:
    1800        77500 :     case TyTy::ARRAY:
    1801        77500 :     case TyTy::SLICE:
    1802        77500 :     case TyTy::FNDEF:
    1803        77500 :     case TyTy::FNPTR:
    1804        77500 :     case TyTy::TUPLE:
    1805        77500 :     case TyTy::BOOL:
    1806        77500 :     case TyTy::CHAR:
    1807        77500 :     case TyTy::INT:
    1808        77500 :     case TyTy::UINT:
    1809        77500 :     case TyTy::FLOAT:
    1810        77500 :     case TyTy::ISIZE:
    1811        77500 :     case TyTy::NEVER:
    1812        77500 :     case TyTy::PLACEHOLDER:
    1813        77500 :     case TyTy::PROJECTION:
    1814        77500 :     case TyTy::DYNAMIC:
    1815        77500 :     case TyTy::CLOSURE:
    1816        77500 :     case TyTy::OPAQUE:
    1817        77500 :     case TyTy::CONST:
    1818        77500 :     case TyTy::ERROR:
    1819        77500 :       return unify_error_type_node ();
    1820              :     }
    1821            0 :   return unify_error_type_node ();
    1822              : }
    1823              : 
    1824              : TyTy::BaseType *
    1825          398 : UnifyRules::expect_never (TyTy::NeverType *ltype, TyTy::BaseType *rtype)
    1826              : {
    1827          398 :   switch (rtype->get_kind ())
    1828              :     {
    1829          130 :     case TyTy::INFER:
    1830          130 :       {
    1831          130 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1832          130 :         bool is_valid
    1833          130 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1834          130 :         if (is_valid)
    1835              :           return ltype;
    1836              :       }
    1837              :       break;
    1838              : 
    1839              :     case TyTy::NEVER:
    1840              :       return ltype;
    1841              : 
    1842          222 :     default:
    1843          222 :       {
    1844          222 :         if (allow_never_coercion)
    1845              :           return rtype;
    1846              :       }
    1847              :       break;
    1848              :     }
    1849           66 :   return unify_error_type_node ();
    1850              : }
    1851              : 
    1852              : TyTy::BaseType *
    1853            0 : UnifyRules::expect_placeholder (TyTy::PlaceholderType *ltype,
    1854              :                                 TyTy::BaseType *rtype)
    1855              : {
    1856            0 :   switch (rtype->get_kind ())
    1857              :     {
    1858            0 :     case TyTy::INFER:
    1859            0 :       {
    1860            0 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1861            0 :         bool is_valid
    1862            0 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1863            0 :         if (is_valid)
    1864              :           return ltype;
    1865              :       }
    1866              :       break;
    1867              : 
    1868              :     case TyTy::PLACEHOLDER:
    1869              :       return ltype;
    1870              : 
    1871            0 :     case TyTy::PROJECTION:
    1872            0 :     case TyTy::DYNAMIC:
    1873            0 :     case TyTy::CLOSURE:
    1874            0 :     case TyTy::SLICE:
    1875            0 :     case TyTy::PARAM:
    1876            0 :     case TyTy::POINTER:
    1877            0 :     case TyTy::STR:
    1878            0 :     case TyTy::ADT:
    1879            0 :     case TyTy::REF:
    1880            0 :     case TyTy::ARRAY:
    1881            0 :     case TyTy::FNDEF:
    1882            0 :     case TyTy::FNPTR:
    1883            0 :     case TyTy::TUPLE:
    1884            0 :     case TyTy::BOOL:
    1885            0 :     case TyTy::CHAR:
    1886            0 :     case TyTy::INT:
    1887            0 :     case TyTy::UINT:
    1888            0 :     case TyTy::FLOAT:
    1889            0 :     case TyTy::USIZE:
    1890            0 :     case TyTy::ISIZE:
    1891            0 :     case TyTy::NEVER:
    1892            0 :     case TyTy::OPAQUE:
    1893            0 :       if (infer_flag)
    1894              :         return rtype;
    1895            0 :       gcc_fallthrough ();
    1896              : 
    1897            0 :     case TyTy::CONST:
    1898            0 :     case TyTy::ERROR:
    1899            0 :       return unify_error_type_node ();
    1900              :     }
    1901            0 :   return unify_error_type_node ();
    1902              : }
    1903              : 
    1904              : TyTy::BaseType *
    1905        18113 : UnifyRules::expect_projection (TyTy::ProjectionType *ltype,
    1906              :                                TyTy::BaseType *rtype)
    1907              : {
    1908        18113 :   switch (rtype->get_kind ())
    1909              :     {
    1910          113 :     case TyTy::INFER:
    1911          113 :       {
    1912          113 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    1913          113 :         bool is_valid
    1914          113 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    1915          113 :         if (is_valid)
    1916              :           return ltype;
    1917              :         // For non-GENERAL infers (INTEGRAL/FLOAT), try normalizing the
    1918              :         // projection first — e.g. unifying `<Bar<i32> as Foo<i32>>::A`
    1919              :         // (still trait-position) with an integer literal needs the
    1920              :         // projection to collapse to `i32` via the impl's `type A = T`.
    1921            9 :         if (ltype->is_trait_position ())
    1922              :           {
    1923            9 :             TyTy::BaseType *ln
    1924            9 :               = normalize_projection (ltype, locus, false, false);
    1925            9 :             if (ln != nullptr && ln != ltype)
    1926            9 :               return resolve_subtype (TyTy::TyWithLocation (ln),
    1927            9 :                                       TyTy::TyWithLocation (rtype));
    1928              :           }
    1929              :       }
    1930              :       break;
    1931              : 
    1932        15294 :     case TyTy::PROJECTION:
    1933        15294 :       {
    1934        15294 :         auto *rtype_proj = static_cast<TyTy::ProjectionType *> (rtype);
    1935              : 
    1936        15294 :         const auto ltype_tref = ltype->get_trait_ref ();
    1937        15294 :         const auto rtype_tref = rtype_proj->get_trait_ref ();
    1938        15294 :         if (!ltype_tref->is_equal (*rtype_tref))
    1939              :           {
    1940              :             // Trait refs differ: try normalizing ltype via the active
    1941              :             // ImplTraitContextFrame before giving up.  This handles cases like
    1942              :             // <[T] as Index<I>>::Output vs <I as SliceIndex<[T]>>::Output where
    1943              :             // the frame resolves Index::Output -> I::Output
    1944              :             // (SliceIndex::Output).
    1945           49 :             if (ltype->is_trait_position ())
    1946              :               {
    1947           49 :                 TyTy::BaseType *ln
    1948           49 :                   = normalize_projection (ltype, locus, false, false);
    1949           49 :                 if (ln != nullptr && ln != ltype)
    1950           49 :                   return resolve_subtype (TyTy::TyWithLocation (ln),
    1951           49 :                                           TyTy::TyWithLocation (rtype));
    1952              :               }
    1953            0 :             return unify_error_type_node ();
    1954              :           }
    1955              : 
    1956        15245 :         auto ltype_item = ltype->get_item_defid ();
    1957        15245 :         auto rtype_item = rtype_proj->get_item_defid ();
    1958        15245 :         if (ltype_item != rtype_item)
    1959            0 :           return unify_error_type_node ();
    1960              : 
    1961        15245 :         auto lrecv = ltype->get_self ();
    1962        15245 :         auto rrecv = rtype_proj->get_self ();
    1963        15245 :         auto res = resolve_subtype (TyTy::TyWithLocation (lrecv),
    1964        15245 :                                     TyTy::TyWithLocation (rrecv));
    1965        15245 :         if (res->get_kind () == TyTy::TypeKind::ERROR)
    1966            0 :           return unify_error_type_node ();
    1967              : 
    1968        15245 :         auto base_res = unify_error_type_node ();
    1969        15245 :         bool ltrait = ltype->is_trait_position ();
    1970        15245 :         bool rtrait = rtype_proj->is_trait_position ();
    1971        15245 :         if (!ltrait && !rtrait)
    1972              :           {
    1973           14 :             auto lbase = ltype->get ();
    1974           14 :             auto rbase = rtype_proj->get ();
    1975           14 :             base_res = resolve_subtype (TyTy::TyWithLocation (lbase),
    1976           14 :                                         TyTy::TyWithLocation (rbase));
    1977           14 :             if (base_res->get_kind () == TyTy::TypeKind::ERROR)
    1978            0 :               return unify_error_type_node ();
    1979              :           }
    1980        15231 :         else if (!ltrait)
    1981            0 :           base_res = ltype->get ();
    1982        15231 :         else if (!rtrait)
    1983        14923 :           base_res = rtype_proj->get ();
    1984              :         else
    1985              :           base_res = nullptr;
    1986              : 
    1987        15245 :         auto result
    1988              :           = new TyTy::ProjectionType (ltype->get_ref (), ltype->get_ty_ref (),
    1989              :                                       base_res, ltype_tref, ltype_item,
    1990        30490 :                                       ltype->get_substs (), res);
    1991        15245 :         return result;
    1992              :       }
    1993         2706 :       break;
    1994              : 
    1995         2706 :     case TyTy::DYNAMIC:
    1996         2706 :     case TyTy::CLOSURE:
    1997         2706 :     case TyTy::SLICE:
    1998         2706 :     case TyTy::PARAM:
    1999         2706 :     case TyTy::POINTER:
    2000         2706 :     case TyTy::STR:
    2001         2706 :     case TyTy::ADT:
    2002         2706 :     case TyTy::REF:
    2003         2706 :     case TyTy::ARRAY:
    2004         2706 :     case TyTy::FNDEF:
    2005         2706 :     case TyTy::FNPTR:
    2006         2706 :     case TyTy::TUPLE:
    2007         2706 :     case TyTy::BOOL:
    2008         2706 :     case TyTy::CHAR:
    2009         2706 :     case TyTy::INT:
    2010         2706 :     case TyTy::UINT:
    2011         2706 :     case TyTy::FLOAT:
    2012         2706 :     case TyTy::USIZE:
    2013         2706 :     case TyTy::ISIZE:
    2014         2706 :     case TyTy::NEVER:
    2015         2706 :     case TyTy::PLACEHOLDER:
    2016         2706 :     case TyTy::OPAQUE:
    2017         2706 :     case TyTy::CONST:
    2018         2706 :       {
    2019         2706 :         if (ltype->is_trait_position ())
    2020              :           {
    2021              :             // A trait-position projection whose Self is still generic cannot be
    2022              :             // normalized against a concrete impl candidate.
    2023         2681 :             auto dself = ltype->get_self ()->destructure ();
    2024         2681 :             if (dself->is<TyTy::ParamType> ())
    2025              :               return ltype;
    2026              : 
    2027         2409 :             TyTy::BaseType *ln
    2028         2409 :               = normalize_projection (ltype, locus, false, false);
    2029         2409 :             if (ln != nullptr && ln != ltype)
    2030         2409 :               return resolve_subtype (TyTy::TyWithLocation (ln),
    2031         2409 :                                       TyTy::TyWithLocation (rtype));
    2032              :           }
    2033              :         else
    2034              :           {
    2035           25 :             TyTy::BaseType *lb = ltype->get ();
    2036           25 :             if (lb != nullptr && lb != ltype)
    2037           25 :               return resolve_subtype (TyTy::TyWithLocation (lb),
    2038           25 :                                       TyTy::TyWithLocation (rtype));
    2039              :           }
    2040              :       }
    2041              :       break;
    2042              : 
    2043            0 :     case TyTy::ERROR:
    2044            0 :       return unify_error_type_node ();
    2045              :     }
    2046            0 :   return unify_error_type_node ();
    2047              : }
    2048              : 
    2049              : TyTy::BaseType *
    2050         4206 : UnifyRules::expect_dyn (TyTy::DynamicObjectType *ltype, TyTy::BaseType *rtype)
    2051              : {
    2052         4206 :   switch (rtype->get_kind ())
    2053              :     {
    2054            8 :     case TyTy::INFER:
    2055            8 :       {
    2056            8 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    2057            8 :         bool is_valid
    2058            8 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    2059            8 :         if (is_valid)
    2060              :           return ltype;
    2061              :       }
    2062              :       break;
    2063              : 
    2064          724 :     case TyTy::DYNAMIC:
    2065          724 :       {
    2066          724 :         TyTy::DynamicObjectType &type
    2067              :           = *static_cast<TyTy::DynamicObjectType *> (rtype);
    2068          724 :         if (ltype->num_specified_bounds () != type.num_specified_bounds ())
    2069              :           {
    2070            0 :             return unify_error_type_node ();
    2071              :           }
    2072              : 
    2073          724 :         if (!ltype->bounds_compatible (type, locus, true))
    2074              :           {
    2075            0 :             return unify_error_type_node ();
    2076              :           }
    2077              : 
    2078              :         return ltype;
    2079              :       }
    2080         3474 :       break;
    2081              : 
    2082         3474 :     case TyTy::CLOSURE:
    2083         3474 :     case TyTy::SLICE:
    2084         3474 :     case TyTy::PARAM:
    2085         3474 :     case TyTy::POINTER:
    2086         3474 :     case TyTy::STR:
    2087         3474 :     case TyTy::ADT:
    2088         3474 :     case TyTy::REF:
    2089         3474 :     case TyTy::ARRAY:
    2090         3474 :     case TyTy::FNDEF:
    2091         3474 :     case TyTy::FNPTR:
    2092         3474 :     case TyTy::TUPLE:
    2093         3474 :     case TyTy::BOOL:
    2094         3474 :     case TyTy::CHAR:
    2095         3474 :     case TyTy::INT:
    2096         3474 :     case TyTy::UINT:
    2097         3474 :     case TyTy::FLOAT:
    2098         3474 :     case TyTy::USIZE:
    2099         3474 :     case TyTy::ISIZE:
    2100         3474 :     case TyTy::NEVER:
    2101         3474 :     case TyTy::PLACEHOLDER:
    2102         3474 :     case TyTy::PROJECTION:
    2103         3474 :     case TyTy::OPAQUE:
    2104         3474 :     case TyTy::CONST:
    2105         3474 :     case TyTy::ERROR:
    2106         3474 :       return unify_error_type_node ();
    2107              :     }
    2108            0 :   return unify_error_type_node ();
    2109              : }
    2110              : 
    2111              : TyTy::BaseType *
    2112          168 : UnifyRules::expect_closure (TyTy::ClosureType *ltype, TyTy::BaseType *rtype)
    2113              : {
    2114          168 :   switch (rtype->get_kind ())
    2115              :     {
    2116            0 :     case TyTy::INFER:
    2117            0 :       {
    2118            0 :         TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
    2119            0 :         bool is_valid
    2120            0 :           = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
    2121            0 :         if (is_valid)
    2122              :           return ltype;
    2123              :       }
    2124              :       break;
    2125              : 
    2126          168 :     case TyTy::CLOSURE:
    2127          168 :       {
    2128          168 :         TyTy::ClosureType &type = *static_cast<TyTy::ClosureType *> (rtype);
    2129          168 :         if (ltype->get_def_id () != type.get_def_id ())
    2130              :           {
    2131            7 :             return unify_error_type_node ();
    2132              :           }
    2133              : 
    2134          161 :         TyTy::BaseType *args_res
    2135          161 :           = resolve_subtype (TyTy::TyWithLocation (&ltype->get_parameters ()),
    2136          161 :                              TyTy::TyWithLocation (&type.get_parameters ()));
    2137          161 :         if (args_res->get_kind () == TyTy::TypeKind::ERROR)
    2138              :           {
    2139            0 :             return unify_error_type_node ();
    2140              :           }
    2141              : 
    2142          161 :         TyTy::BaseType *res
    2143          161 :           = resolve_subtype (TyTy::TyWithLocation (&ltype->get_result_type ()),
    2144          161 :                              TyTy::TyWithLocation (&type.get_result_type ()));
    2145          161 :         if (res == nullptr || res->get_kind () == TyTy::TypeKind::ERROR)
    2146              :           {
    2147            0 :             return unify_error_type_node ();
    2148              :           }
    2149              : 
    2150              :         return ltype;
    2151              :       }
    2152            0 :       break;
    2153              : 
    2154            0 :     case TyTy::SLICE:
    2155            0 :     case TyTy::PARAM:
    2156            0 :     case TyTy::POINTER:
    2157            0 :     case TyTy::STR:
    2158            0 :     case TyTy::ADT:
    2159            0 :     case TyTy::REF:
    2160            0 :     case TyTy::ARRAY:
    2161            0 :     case TyTy::FNDEF:
    2162            0 :     case TyTy::FNPTR:
    2163            0 :     case TyTy::TUPLE:
    2164            0 :     case TyTy::BOOL:
    2165            0 :     case TyTy::CHAR:
    2166            0 :     case TyTy::INT:
    2167            0 :     case TyTy::UINT:
    2168            0 :     case TyTy::FLOAT:
    2169            0 :     case TyTy::USIZE:
    2170            0 :     case TyTy::ISIZE:
    2171            0 :     case TyTy::NEVER:
    2172            0 :     case TyTy::PLACEHOLDER:
    2173            0 :     case TyTy::PROJECTION:
    2174            0 :     case TyTy::DYNAMIC:
    2175            0 :     case TyTy::OPAQUE:
    2176            0 :     case TyTy::CONST:
    2177            0 :     case TyTy::ERROR:
    2178            0 :       return unify_error_type_node ();
    2179              :     }
    2180            0 :   return unify_error_type_node ();
    2181              : }
    2182              : 
    2183              : TyTy::BaseType *
    2184          249 : UnifyRules::expect_opaque (TyTy::OpaqueType *ltype, TyTy::BaseType *rtype)
    2185              : {
    2186          249 :   if (rtype->is<TyTy::OpaqueType> ())
    2187              :     {
    2188           73 :       TyTy::OpaqueType *ro = rtype->as<TyTy::OpaqueType> ();
    2189           73 :       if (!ltype->is_equal (*ro))
    2190            0 :         return unify_error_type_node ();
    2191              : 
    2192           73 :       if (ltype->can_resolve () && ro->can_resolve ())
    2193              :         {
    2194           73 :           auto lr = ltype->resolve ();
    2195           73 :           auto rr = ro->resolve ();
    2196              : 
    2197           73 :           auto res = resolve_subtype (TyTy::TyWithLocation (lr),
    2198           73 :                                       TyTy::TyWithLocation (rr));
    2199           73 :           if (res->get_kind () == TyTy::TypeKind::ERROR)
    2200            0 :             return unify_error_type_node ();
    2201              :         }
    2202            0 :       else if (ltype->can_resolve ())
    2203              :         {
    2204            0 :           auto lr = ltype->resolve ();
    2205            0 :           ro->set_ty_ref (lr->get_ref ());
    2206              :         }
    2207            0 :       else if (ro->can_resolve ())
    2208              :         {
    2209            0 :           auto rr = ro->resolve ();
    2210            0 :           ltype->set_ty_ref (rr->get_ref ());
    2211              :         }
    2212              :     }
    2213          176 :   else if (ltype->can_resolve ())
    2214              :     {
    2215          147 :       auto underly = ltype->resolve ();
    2216          147 :       auto res = resolve_subtype (TyTy::TyWithLocation (underly),
    2217          147 :                                   TyTy::TyWithLocation (rtype));
    2218          147 :       if (res->get_kind () == TyTy::TypeKind::ERROR)
    2219            2 :         return unify_error_type_node ();
    2220              :     }
    2221              :   else
    2222              :     {
    2223           29 :       ltype->set_ty_ref (rtype->get_ref ());
    2224              :     }
    2225              : 
    2226              :   return ltype;
    2227              : }
    2228              : 
    2229              : TyTy::BaseType *
    2230         1810 : UnifyRules::expect_const (TyTy::BaseConstType *ltype, TyTy::BaseType *rtype)
    2231              : {
    2232         1810 :   if (rtype->get_kind () != TyTy::TypeKind::CONST)
    2233            0 :     return unify_error_type_node ();
    2234              : 
    2235         1810 :   auto &lhs = *ltype;
    2236         1810 :   auto &rhs = *rtype->as_const_type ();
    2237              : 
    2238              :   // Handle error types early
    2239         1810 :   if (lhs.const_kind () == TyTy::BaseConstType::ConstKind::Error
    2240         1810 :       || rhs.const_kind () == TyTy::BaseConstType::ConstKind::Error)
    2241              :     {
    2242            4 :       auto lhs_base = ltype->as_base_type ();
    2243            4 :       return new TyTy::ConstErrorType (lhs.get_specified_type (),
    2244              :                                        lhs_base->get_ref (),
    2245              :                                        lhs_base->get_ty_ref (),
    2246            4 :                                        lhs_base->get_combined_refs ());
    2247              :     }
    2248              : 
    2249              :   // Try to resolve Decl types (ConstParamType)
    2250         1806 :   TyTy::BaseConstType *resolved_lhs = &lhs;
    2251         1806 :   TyTy::BaseConstType *resolved_rhs = &rhs;
    2252              : 
    2253         1806 :   if (lhs.const_kind () == TyTy::BaseConstType::ConstKind::Decl)
    2254              :     {
    2255           22 :       auto *param = static_cast<TyTy::ConstParamType *> (&lhs);
    2256           22 :       if (param->can_resolve ())
    2257              :         {
    2258            0 :           auto *resolved = param->resolve ();
    2259            0 :           if (resolved->get_kind () == TyTy::TypeKind::CONST)
    2260            0 :             resolved_lhs = resolved->as_const_type ();
    2261              :         }
    2262              :     }
    2263              : 
    2264         1806 :   if (rhs.const_kind () == TyTy::BaseConstType::ConstKind::Decl)
    2265              :     {
    2266           22 :       auto *param = static_cast<TyTy::ConstParamType *> (&rhs);
    2267           22 :       if (param->can_resolve ())
    2268              :         {
    2269            0 :           auto *resolved = param->resolve ();
    2270            0 :           if (resolved->get_kind () == TyTy::TypeKind::CONST)
    2271            0 :             resolved_rhs = resolved->as_const_type ();
    2272              :         }
    2273              :     }
    2274              : 
    2275         3612 :   auto res = resolve_subtype (
    2276         1806 :     TyTy::TyWithLocation (resolved_lhs->get_specified_type ()),
    2277         1806 :     TyTy::TyWithLocation (resolved_rhs->get_specified_type ()));
    2278         1806 :   if (res->get_kind () == TyTy::TypeKind::ERROR)
    2279            0 :     return unify_error_type_node ();
    2280              : 
    2281         1806 :   if (resolved_lhs->const_kind () == TyTy::BaseConstType::ConstKind::Value
    2282         1806 :       && resolved_rhs->const_kind () == TyTy::BaseConstType::ConstKind::Value)
    2283              :     {
    2284         1677 :       auto vlhs = static_cast<TyTy::ConstValueType &> (*resolved_lhs);
    2285         1677 :       auto vrhs = static_cast<TyTy::ConstValueType &> (*resolved_rhs);
    2286         1677 :       tree lv = vlhs.get_value ();
    2287         1677 :       tree rv = vrhs.get_value ();
    2288              : 
    2289         1677 :       bool ok = operand_equal_p (lv, rv, 0);
    2290         1677 :       if (!ok)
    2291           75 :         return unify_error_type_node ();
    2292              :       else
    2293              :         {
    2294         1602 :           auto lhs_base = resolved_lhs->as_base_type ();
    2295         1602 :           return new TyTy::ConstValueType (lv, res, lhs_base->get_ref (),
    2296              :                                            lhs_base->get_ty_ref (),
    2297         1602 :                                            lhs_base->get_combined_refs ());
    2298              :         }
    2299         1677 :     }
    2300          129 :   else if (resolved_lhs->const_kind () == TyTy::BaseConstType::ConstKind::Infer
    2301          129 :            && resolved_rhs->const_kind ()
    2302              :                 == TyTy::BaseConstType::ConstKind::Value)
    2303           40 :     return resolved_rhs->as_base_type ();
    2304           89 :   else if (resolved_rhs->const_kind () == TyTy::BaseConstType::ConstKind::Infer
    2305           89 :            && resolved_lhs->const_kind ()
    2306              :                 == TyTy::BaseConstType::ConstKind::Value)
    2307           67 :     return resolved_lhs->as_base_type ();
    2308           22 :   else if (resolved_lhs->const_kind () == TyTy::BaseConstType::ConstKind::Infer
    2309           22 :            && resolved_rhs->const_kind ()
    2310              :                 == TyTy::BaseConstType::ConstKind::Infer)
    2311            0 :     return resolved_lhs->as_base_type ();
    2312           22 :   else if (resolved_lhs->const_kind () == TyTy::BaseConstType::ConstKind::Decl
    2313           22 :            || resolved_rhs->const_kind ()
    2314              :                 == TyTy::BaseConstType::ConstKind::Decl)
    2315              :     {
    2316              :       // If we still have unresolved Decl after trying to resolve, unify with it
    2317              :       // This allows const inference to work
    2318           22 :       if (resolved_lhs->const_kind () == TyTy::BaseConstType::ConstKind::Decl
    2319           22 :           && resolved_rhs->const_kind ()
    2320              :                != TyTy::BaseConstType::ConstKind::Decl)
    2321            0 :         return resolved_rhs->as_base_type ();
    2322           22 :       else if (resolved_rhs->const_kind ()
    2323              :                  == TyTy::BaseConstType::ConstKind::Decl
    2324           22 :                && resolved_lhs->const_kind ()
    2325              :                     != TyTy::BaseConstType::ConstKind::Decl)
    2326            0 :         return resolved_lhs->as_base_type ();
    2327              :       // Both are Decl - return lhs
    2328           22 :       return resolved_lhs->as_base_type ();
    2329              :     }
    2330              : 
    2331            0 :   return unify_error_type_node ();
    2332              : }
    2333              : 
    2334              : } // namespace Resolver
    2335              : } // namespace Rust
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.