gcc/rust/typecheck/rust-tyty-rules.h

   1 // Copyright (C) 2020-2023 Free Software Foundation, Inc.
   2
   3 // This file is part of GCC.
   4
   5 // GCC is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 3, or (at your option) any later
   8 // version.
   9
  10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 // for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with GCC; see the file COPYING3.  If not see
  17 // <http://www.gnu.org/licenses/>.
  18
  19 #ifndef RUST_TYTY_RULES
  20 #define RUST_TYTY_RULES
  21
  22 #include "rust-diagnostics.h"
  23 #include "rust-tyty.h"
  24 #include "rust-tyty-visitor.h"
  25 #include "rust-hir-map.h"
  26 #include "rust-hir-type-check.h"
  27
  28 namespace Rust {
  29 namespace TyTy {
  30
  31 /* Rules specify how to unify two Ty. For example, the result of unifying the
  32    two tuples (u64, A) and (B, i64) would be (u64, i64).
  33
  34    Performing a unification requires a double dispatch. To illustrate, suppose
  35    we want to unify `ty1` and `ty2`. Here's what it looks like:
  36      1. The caller calls `ty1.unify(ty2)`. This is the first dispatch.
  37      2. `ty1` creates a rule specific to its type(e.g. TupleRules).
  38      3. The rule calls `ty2.accept_vis(rule)`. This is the second dispatch.
  39      4. `ty2` calls `rule.visit(*this)`, which will method-overload to the
  40               correct implementation at compile time.
  41
  42    The nice thing about Rules is that they seperate unification logic from the
  43    representation of Ty. To support unifying a new Ty, implement its
  44    `accept_vis` and `unify` method to pass the unification request to Rules.
  45    Then, create a new `XXXRules` class and implement one `visit` method for
  46    every Ty it can unify with. */
  47 class BaseRules : public TyVisitor
  48 {
  49 public:
  50   virtual ~BaseRules () {}
  51
  52   /* Unify two ty. Returns a pointer to the newly-created unified ty, or nullptr
  53      if the two types cannot be unified. The caller is responsible for releasing
  54      the memory of the returned ty.
  55
  56      This method is meant to be used internally by Ty. If you're trying to unify
  57      two ty, you can simply call `unify` on ty themselves. */
  58   virtual BaseType *unify (BaseType *other)
  59   {
  60     if (other->get_kind () == TypeKind::PARAM)
  61       {
  62         ParamType *p = static_cast<ParamType *> (other);
  63         other = p->resolve ();
  64       }
  65     else if (other->get_kind () == TypeKind::PLACEHOLDER)
  66       {
  67         PlaceholderType *p = static_cast<PlaceholderType *> (other);
  68         if (p->can_resolve ())
  69           {
  70             other = p->resolve ();
  71             return get_base ()->unify (other);
  72           }
  73       }
  74     else if (other->get_kind () == TypeKind::PROJECTION)
  75       {
  76         ProjectionType *p = static_cast<ProjectionType *> (other);
  77         other = p->get ();
  78         return get_base ()->unify (other);
  79       }
  80
  81     other->accept_vis (*this);
  82     if (resolved->get_kind () == TyTy::TypeKind::ERROR)
  83       return resolved;
  84
  85     resolved->append_reference (get_base ()->get_ref ());
  86     resolved->append_reference (other->get_ref ());
  87     for (auto ref : get_base ()->get_combined_refs ())
  88       resolved->append_reference (ref);
  89     for (auto ref : other->get_combined_refs ())
  90       resolved->append_reference (ref);
  91
  92     other->append_reference (resolved->get_ref ());
  93     other->append_reference (get_base ()->get_ref ());
  94     get_base ()->append_reference (resolved->get_ref ());
  95     get_base ()->append_reference (other->get_ref ());
  96
  97     bool result_resolved = resolved->get_kind () != TyTy::TypeKind::INFER;
  98     bool result_is_infer_var = resolved->get_kind () == TyTy::TypeKind::INFER;
  99     bool results_is_non_general_infer_var
 100       = (result_is_infer_var
 101          && (static_cast<InferType *> (resolved))->get_infer_kind ()
 102               != TyTy::InferType::GENERAL);
 103     if (result_resolved || results_is_non_general_infer_var)
 104       {
 105         for (auto &ref : resolved->get_combined_refs ())
 106           {
 107             TyTy::BaseType *ref_tyty = nullptr;
 108             bool ok = context->lookup_type (ref, &ref_tyty);
 109             if (!ok)
 110               continue;
 111
 112             // if any of the types are inference variables lets fix them
 113             if (ref_tyty->get_kind () == TyTy::TypeKind::INFER)
 114               {
 115                 context->insert_type (
 116                   Analysis::NodeMapping (mappings->get_current_crate (),
 117                                          UNKNOWN_NODEID, ref,
 118                                          UNKNOWN_LOCAL_DEFID),
 119                   resolved->clone ());
 120               }
 121           }
 122       }
 123     return resolved;
 124   }
 125
 126   virtual void visit (TupleType &type) override {}
 127
 128   virtual void visit (ADTType &type) override {}
 129
 130   virtual void visit (InferType &type) override {}
 131
 132   virtual void visit (FnType &type) override {}
 133
 134   virtual void visit (FnPtr &type) override {}
 135
 136   virtual void visit (ArrayType &type) override {}
 137
 138   virtual void visit (SliceType &type) override {}
 139
 140   virtual void visit (BoolType &type) override {}
 141
 142   virtual void visit (IntType &type) override {}
 143
 144   virtual void visit (UintType &type) override {}
 145
 146   virtual void visit (USizeType &type) override {}
 147
 148   virtual void visit (ISizeType &type) override {}
 149
 150   virtual void visit (FloatType &type) override {}
 151
 152   virtual void visit (ErrorType &type) override {}
 153
 154   virtual void visit (CharType &type) override {}
 155
 156   virtual void visit (ReferenceType &type) override {}
 157
 158   virtual void visit (PointerType &type) override {}
 159
 160   virtual void visit (ParamType &type) override {}
 161
 162   virtual void visit (StrType &type) override {}
 163
 164   virtual void visit (NeverType &type) override {}
 165
 166   virtual void visit (PlaceholderType &type) override {}
 167
 168   virtual void visit (ProjectionType &type) override {}
 169
 170   virtual void visit (DynamicObjectType &type) override {}
 171
 172   virtual void visit (ClosureType &type) override {}
 173
 174 protected:
 175   BaseRules (BaseType *base)
 176     : mappings (Analysis::Mappings::get ()),
 177       context (Resolver::TypeCheckContext::get ()),
 178       resolved (new ErrorType (base->get_ref (), base->get_ref ()))
 179   {}
 180
 181   Analysis::Mappings *mappings;
 182   Resolver::TypeCheckContext *context;
 183
 184   /* Temporary storage for the result of a unification.
 185      We could return the result directly instead of storing it in the rule
 186      object, but that involves modifying the visitor pattern to accommodate
 187      the return value, which is too complex. */
 188   BaseType *resolved;
 189
 190 private:
 191   /* Returns a pointer to the ty that created this rule. */
 192   virtual BaseType *get_base () = 0;
 193 };
 194
 195 class InferRules : public BaseRules
 196 {
 197   using Rust::TyTy::BaseRules::visit;
 198
 199 public:
 200   InferRules (InferType *base) : BaseRules (base), base (base) {}
 201
 202   void visit (BoolType &type) override
 203   {
 204     bool is_valid
 205       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 206     if (is_valid)
 207       {
 208         resolved = type.clone ();
 209         return;
 210       }
 211
 212     BaseRules::visit (type);
 213   }
 214
 215   void visit (IntType &type) override
 216   {
 217     bool is_valid
 218       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL)
 219         || (base->get_infer_kind ()
 220             == TyTy::InferType::InferTypeKind::INTEGRAL);
 221     if (is_valid)
 222       {
 223         resolved = type.clone ();
 224         return;
 225       }
 226
 227     BaseRules::visit (type);
 228   }
 229
 230   void visit (UintType &type) override
 231   {
 232     bool is_valid
 233       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL)
 234         || (base->get_infer_kind ()
 235             == TyTy::InferType::InferTypeKind::INTEGRAL);
 236     if (is_valid)
 237       {
 238         resolved = type.clone ();
 239         return;
 240       }
 241
 242     BaseRules::visit (type);
 243   }
 244
 245   void visit (USizeType &type) override
 246   {
 247     bool is_valid
 248       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL)
 249         || (base->get_infer_kind ()
 250             == TyTy::InferType::InferTypeKind::INTEGRAL);
 251     if (is_valid)
 252       {
 253         resolved = type.clone ();
 254         return;
 255       }
 256
 257     BaseRules::visit (type);
 258   }
 259
 260   void visit (ISizeType &type) override
 261   {
 262     bool is_valid
 263       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL)
 264         || (base->get_infer_kind ()
 265             == TyTy::InferType::InferTypeKind::INTEGRAL);
 266     if (is_valid)
 267       {
 268         resolved = type.clone ();
 269         return;
 270       }
 271
 272     BaseRules::visit (type);
 273   }
 274
 275   void visit (FloatType &type) override
 276   {
 277     bool is_valid
 278       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL)
 279         || (base->get_infer_kind () == TyTy::InferType::InferTypeKind::FLOAT);
 280     if (is_valid)
 281       {
 282         resolved = type.clone ();
 283         return;
 284       }
 285
 286     BaseRules::visit (type);
 287   }
 288
 289   void visit (ArrayType &type) override
 290   {
 291     bool is_valid
 292       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 293     if (is_valid)
 294       {
 295         resolved = type.clone ();
 296         return;
 297       }
 298
 299     BaseRules::visit (type);
 300   }
 301
 302   void visit (SliceType &type) override
 303   {
 304     bool is_valid
 305       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 306     if (is_valid)
 307       {
 308         resolved = type.clone ();
 309         return;
 310       }
 311
 312     BaseRules::visit (type);
 313   }
 314
 315   void visit (ADTType &type) override
 316   {
 317     bool is_valid
 318       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 319     if (is_valid)
 320       {
 321         resolved = type.clone ();
 322         return;
 323       }
 324
 325     BaseRules::visit (type);
 326   }
 327
 328   void visit (TupleType &type) override
 329   {
 330     bool is_valid
 331       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 332     if (is_valid)
 333       {
 334         resolved = type.clone ();
 335         return;
 336       }
 337
 338     BaseRules::visit (type);
 339   }
 340
 341   void visit (InferType &type) override
 342   {
 343     switch (base->get_infer_kind ())
 344       {
 345       case InferType::InferTypeKind::GENERAL:
 346         resolved = type.clone ();
 347         return;
 348
 349         case InferType::InferTypeKind::INTEGRAL: {
 350           if (type.get_infer_kind () == InferType::InferTypeKind::INTEGRAL)
 351             {
 352               resolved = type.clone ();
 353               return;
 354             }
 355           else if (type.get_infer_kind () == InferType::InferTypeKind::GENERAL)
 356             {
 357               resolved = base->clone ();
 358               return;
 359             }
 360         }
 361         break;
 362
 363         case InferType::InferTypeKind::FLOAT: {
 364           if (type.get_infer_kind () == InferType::InferTypeKind::FLOAT)
 365             {
 366               resolved = type.clone ();
 367               return;
 368             }
 369           else if (type.get_infer_kind () == InferType::InferTypeKind::GENERAL)
 370             {
 371               resolved = base->clone ();
 372               return;
 373             }
 374         }
 375         break;
 376       }
 377
 378     BaseRules::visit (type);
 379   }
 380
 381   void visit (CharType &type) override
 382   {
 383     {
 384       bool is_valid
 385         = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 386       if (is_valid)
 387         {
 388           resolved = type.clone ();
 389           return;
 390         }
 391
 392       BaseRules::visit (type);
 393     }
 394   }
 395
 396   void visit (ReferenceType &type) override
 397   {
 398     bool is_valid
 399       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 400     if (is_valid)
 401       {
 402         resolved = type.clone ();
 403         return;
 404       }
 405
 406     BaseRules::visit (type);
 407   }
 408
 409   void visit (PointerType &type) override
 410   {
 411     bool is_valid
 412       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 413     if (is_valid)
 414       {
 415         resolved = type.clone ();
 416         return;
 417       }
 418
 419     BaseRules::visit (type);
 420   }
 421
 422   void visit (ParamType &type) override
 423   {
 424     bool is_valid
 425       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 426     if (is_valid)
 427       {
 428         resolved = type.clone ();
 429         return;
 430       }
 431
 432     BaseRules::visit (type);
 433   }
 434
 435   void visit (DynamicObjectType &type) override
 436   {
 437     bool is_valid
 438       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 439     if (is_valid)
 440       {
 441         resolved = type.clone ();
 442         return;
 443       }
 444
 445     BaseRules::visit (type);
 446   }
 447
 448   void visit (ClosureType &type) override
 449   {
 450     bool is_valid
 451       = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
 452     if (is_valid)
 453       {
 454         resolved = type.clone ();
 455         return;
 456       }
 457
 458     BaseRules::visit (type);
 459   }
 460
 461 private:
 462   BaseType *get_base () override { return base; }
 463
 464   InferType *base;
 465 };
 466
 467 class FnRules : public BaseRules
 468 {
 469   using Rust::TyTy::BaseRules::visit;
 470
 471 public:
 472   FnRules (FnType *base) : BaseRules (base), base (base) {}
 473
 474   void visit (InferType &type) override
 475   {
 476     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
 477       {
 478         BaseRules::visit (type);
 479         return;
 480       }
 481
 482     resolved = base->clone ();
 483     resolved->set_ref (type.get_ref ());
 484   }
 485
 486   void visit (FnType &type) override
 487   {
 488     if (base->num_params () != type.num_params ())
 489       {
 490         BaseRules::visit (type);
 491         return;
 492       }
 493
 494     for (size_t i = 0; i < base->num_params (); i++)
 495       {
 496         auto a = base->param_at (i).second;
 497         auto b = type.param_at (i).second;
 498
 499         auto unified_param = a->unify (b);
 500         if (unified_param == nullptr)
 501           {
 502             BaseRules::visit (type);
 503             return;
 504           }
 505       }
 506
 507     auto unified_return
 508       = base->get_return_type ()->unify (type.get_return_type ());
 509     if (unified_return == nullptr)
 510       {
 511         BaseRules::visit (type);
 512         return;
 513       }
 514
 515     resolved = base->clone ();
 516     resolved->set_ref (type.get_ref ());
 517   }
 518
 519 private:
 520   BaseType *get_base () override { return base; }
 521
 522   FnType *base;
 523 };
 524
 525 class FnptrRules : public BaseRules
 526 {
 527   using Rust::TyTy::BaseRules::visit;
 528
 529 public:
 530   FnptrRules (FnPtr *base) : BaseRules (base), base (base) {}
 531
 532   void visit (InferType &type) override
 533   {
 534     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
 535       {
 536         BaseRules::visit (type);
 537         return;
 538       }
 539
 540     resolved = base->clone ();
 541     resolved->set_ref (type.get_ref ());
 542   }
 543
 544   void visit (FnPtr &type) override
 545   {
 546     auto this_ret_type = base->get_return_type ();
 547     auto other_ret_type = type.get_return_type ();
 548     auto unified_result = this_ret_type->unify (other_ret_type);
 549     if (unified_result == nullptr
 550         || unified_result->get_kind () == TypeKind::ERROR)
 551       {
 552         BaseRules::visit (type);
 553         return;
 554       }
 555
 556     if (base->num_params () != type.num_params ())
 557       {
 558         BaseRules::visit (type);
 559         return;
 560       }
 561
 562     for (size_t i = 0; i < base->num_params (); i++)
 563       {
 564         auto this_param = base->param_at (i);
 565         auto other_param = type.param_at (i);
 566         auto unified_param = this_param->unify (other_param);
 567         if (unified_param == nullptr
 568             || unified_param->get_kind () == TypeKind::ERROR)
 569           {
 570             BaseRules::visit (type);
 571             return;
 572           }
 573       }
 574
 575     resolved = base->clone ();
 576     resolved->set_ref (type.get_ref ());
 577   }
 578
 579   void visit (FnType &type) override
 580   {
 581     auto this_ret_type = base->get_return_type ();
 582     auto other_ret_type = type.get_return_type ();
 583     auto unified_result = this_ret_type->unify (other_ret_type);
 584     if (unified_result == nullptr
 585         || unified_result->get_kind () == TypeKind::ERROR)
 586       {
 587         BaseRules::visit (type);
 588         return;
 589       }
 590
 591     if (base->num_params () != type.num_params ())
 592       {
 593         BaseRules::visit (type);
 594         return;
 595       }
 596
 597     for (size_t i = 0; i < base->num_params (); i++)
 598       {
 599         auto this_param = base->param_at (i);
 600         auto other_param = type.param_at (i).second;
 601         auto unified_param = this_param->unify (other_param);
 602         if (unified_param == nullptr
 603             || unified_param->get_kind () == TypeKind::ERROR)
 604           {
 605             BaseRules::visit (type);
 606             return;
 607           }
 608       }
 609
 610     resolved = base->clone ();
 611     resolved->set_ref (type.get_ref ());
 612   }
 613
 614 private:
 615   BaseType *get_base () override { return base; }
 616
 617   FnPtr *base;
 618 };
 619
 620 class ClosureRules : public BaseRules
 621 {
 622   using Rust::TyTy::BaseRules::visit;
 623
 624 public:
 625   ClosureRules (ClosureType *base) : BaseRules (base), base (base) {}
 626
 627   // TODO
 628
 629 private:
 630   BaseType *get_base () override { return base; }
 631
 632   ClosureType *base;
 633 };
 634
 635 class ArrayRules : public BaseRules
 636 {
 637   using Rust::TyTy::BaseRules::visit;
 638
 639 public:
 640   ArrayRules (ArrayType *base) : BaseRules (base), base (base) {}
 641
 642   void visit (ArrayType &type) override
 643   {
 644     // check base type
 645     auto base_resolved
 646       = base->get_element_type ()->unify (type.get_element_type ());
 647     if (base_resolved == nullptr)
 648       {
 649         BaseRules::visit (type);
 650         return;
 651       }
 652
 653     resolved
 654       = new ArrayType (type.get_ref (), type.get_ty_ref (),
 655                        type.get_ident ().locus, type.get_capacity_expr (),
 656                        TyVar (base_resolved->get_ref ()));
 657   }
 658
 659   void visit (InferType &type) override
 660   {
 661     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
 662       {
 663         BaseRules::visit (type);
 664         return;
 665       }
 666
 667     resolved = base->clone ();
 668     resolved->set_ref (type.get_ref ());
 669   }
 670
 671 private:
 672   BaseType *get_base () override { return base; }
 673
 674   ArrayType *base;
 675 };
 676
 677 class SliceRules : public BaseRules
 678 {
 679   using Rust::TyTy::BaseRules::visit;
 680
 681 public:
 682   SliceRules (SliceType *base) : BaseRules (base), base (base) {}
 683
 684   void visit (SliceType &type) override
 685   {
 686     // check base type
 687     auto base_resolved
 688       = base->get_element_type ()->unify (type.get_element_type ());
 689     if (base_resolved == nullptr)
 690       {
 691         BaseRules::visit (type);
 692         return;
 693       }
 694
 695     resolved = new SliceType (type.get_ref (), type.get_ty_ref (),
 696                               type.get_ident ().locus,
 697                               TyVar (base_resolved->get_ref ()));
 698   }
 699
 700   void visit (InferType &type) override
 701   {
 702     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
 703       {
 704         BaseRules::visit (type);
 705         return;
 706       }
 707
 708     resolved = base->clone ();
 709     resolved->set_ref (type.get_ref ());
 710   }
 711
 712 private:
 713   BaseType *get_base () override { return base; }
 714
 715   SliceType *base;
 716 };
 717
 718 class BoolRules : public BaseRules
 719 {
 720   using Rust::TyTy::BaseRules::visit;
 721
 722 public:
 723   BoolRules (BoolType *base) : BaseRules (base), base (base) {}
 724
 725   void visit (BoolType &type) override
 726   {
 727     resolved = new BoolType (type.get_ref (), type.get_ty_ref ());
 728   }
 729
 730   void visit (InferType &type) override
 731   {
 732     switch (type.get_infer_kind ())
 733       {
 734       case InferType::InferTypeKind::GENERAL:
 735         resolved = base->clone ();
 736         break;
 737
 738       default:
 739         BaseRules::visit (type);
 740         break;
 741       }
 742   }
 743
 744 private:
 745   BaseType *get_base () override { return base; }
 746
 747   BoolType *base;
 748 };
 749
 750 class IntRules : public BaseRules
 751 {
 752   using Rust::TyTy::BaseRules::visit;
 753
 754 public:
 755   IntRules (IntType *base) : BaseRules (base), base (base) {}
 756
 757   void visit (InferType &type) override
 758   {
 759     // cant assign a float inference variable
 760     if (type.get_infer_kind () == InferType::InferTypeKind::FLOAT)
 761       {
 762         BaseRules::visit (type);
 763         return;
 764       }
 765
 766     resolved = base->clone ();
 767     resolved->set_ref (type.get_ref ());
 768   }
 769
 770   void visit (IntType &type) override
 771   {
 772     if (type.get_int_kind () != base->get_int_kind ())
 773       {
 774         BaseRules::visit (type);
 775         return;
 776       }
 777
 778     resolved
 779       = new IntType (type.get_ref (), type.get_ty_ref (), type.get_int_kind ());
 780   }
 781
 782 private:
 783   BaseType *get_base () override { return base; }
 784
 785   IntType *base;
 786 };
 787
 788 class UintRules : public BaseRules
 789 {
 790   using Rust::TyTy::BaseRules::visit;
 791
 792 public:
 793   UintRules (UintType *base) : BaseRules (base), base (base) {}
 794
 795   void visit (InferType &type) override
 796   {
 797     // cant assign a float inference variable
 798     if (type.get_infer_kind () == InferType::InferTypeKind::FLOAT)
 799       {
 800         BaseRules::visit (type);
 801         return;
 802       }
 803
 804     resolved = base->clone ();
 805     resolved->set_ref (type.get_ref ());
 806   }
 807
 808   void visit (UintType &type) override
 809   {
 810     if (type.get_uint_kind () != base->get_uint_kind ())
 811       {
 812         BaseRules::visit (type);
 813         return;
 814       }
 815
 816     resolved = new UintType (type.get_ref (), type.get_ty_ref (),
 817                              type.get_uint_kind ());
 818   }
 819
 820 private:
 821   BaseType *get_base () override { return base; }
 822
 823   UintType *base;
 824 };
 825
 826 class FloatRules : public BaseRules
 827 {
 828   using Rust::TyTy::BaseRules::visit;
 829
 830 public:
 831   FloatRules (FloatType *base) : BaseRules (base), base (base) {}
 832
 833   void visit (InferType &type) override
 834   {
 835     if (type.get_infer_kind () == InferType::InferTypeKind::INTEGRAL)
 836       {
 837         BaseRules::visit (type);
 838         return;
 839       }
 840
 841     resolved = base->clone ();
 842     resolved->set_ref (type.get_ref ());
 843   }
 844
 845   void visit (FloatType &type) override
 846   {
 847     if (type.get_float_kind () != base->get_float_kind ())
 848       {
 849         BaseRules::visit (type);
 850         return;
 851       }
 852
 853     resolved = new FloatType (type.get_ref (), type.get_ty_ref (),
 854                               type.get_float_kind ());
 855   }
 856
 857 private:
 858   BaseType *get_base () override { return base; }
 859
 860   FloatType *base;
 861 };
 862
 863 class ADTRules : public BaseRules
 864 {
 865   using Rust::TyTy::BaseRules::visit;
 866
 867 public:
 868   ADTRules (ADTType *base) : BaseRules (base), base (base) {}
 869
 870   void visit (ADTType &type) override
 871   {
 872     if (base->get_adt_kind () != type.get_adt_kind ())
 873       {
 874         BaseRules::visit (type);
 875         return;
 876       }
 877
 878     if (base->get_identifier ().compare (type.get_identifier ()) != 0)
 879       {
 880         BaseRules::visit (type);
 881         return;
 882       }
 883
 884     if (base->number_of_variants () != type.number_of_variants ())
 885       {
 886         BaseRules::visit (type);
 887         return;
 888       }
 889
 890     for (size_t i = 0; i < type.number_of_variants (); ++i)
 891       {
 892         TyTy::VariantDef *a = base->get_variants ().at (i);
 893         TyTy::VariantDef *b = type.get_variants ().at (i);
 894
 895         if (a->num_fields () != b->num_fields ())
 896           {
 897             BaseRules::visit (type);
 898             return;
 899           }
 900
 901         for (size_t j = 0; j < a->num_fields (); j++)
 902           {
 903             TyTy::StructFieldType *base_field = a->get_field_at_index (j);
 904             TyTy::StructFieldType *other_field = b->get_field_at_index (j);
 905
 906             TyTy::BaseType *this_field_ty = base_field->get_field_type ();
 907             TyTy::BaseType *other_field_ty = other_field->get_field_type ();
 908
 909             BaseType *unified_ty = this_field_ty->unify (other_field_ty);
 910             if (unified_ty->get_kind () == TyTy::TypeKind::ERROR)
 911               return;
 912           }
 913       }
 914
 915     // generic args for the unit-struct case
 916     if (type.is_unit () && base->is_unit ())
 917       {
 918         rust_assert (type.get_num_substitutions ()
 919                      == base->get_num_substitutions ());
 920
 921         for (size_t i = 0; i < type.get_num_substitutions (); i++)
 922           {
 923             auto &a = base->get_substs ().at (i);
 924             auto &b = type.get_substs ().at (i);
 925
 926             auto pa = a.get_param_ty ();
 927             auto pb = b.get_param_ty ();
 928
 929             auto res = pa->unify (pb);
 930             if (res->get_kind () == TyTy::TypeKind::ERROR)
 931               {
 932                 return;
 933               }
 934           }
 935       }
 936
 937     resolved = type.clone ();
 938   }
 939
 940   void visit (InferType &type) override
 941   {
 942     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
 943       {
 944         BaseRules::visit (type);
 945         return;
 946       }
 947
 948     resolved = base->clone ();
 949     resolved->set_ref (type.get_ref ());
 950   }
 951
 952 private:
 953   BaseType *get_base () override { return base; }
 954
 955   ADTType *base;
 956 };
 957
 958 class TupleRules : public BaseRules
 959 {
 960   using Rust::TyTy::BaseRules::visit;
 961
 962 public:
 963   TupleRules (TupleType *base) : BaseRules (base), base (base) {}
 964
 965   void visit (TupleType &type) override
 966   {
 967     if (base->num_fields () != type.num_fields ())
 968       {
 969         BaseRules::visit (type);
 970         return;
 971       }
 972
 973     std::vector<TyVar> fields;
 974     for (size_t i = 0; i < base->num_fields (); i++)
 975       {
 976         BaseType *bo = base->get_field (i);
 977         BaseType *fo = type.get_field (i);
 978
 979         BaseType *unified_ty = bo->unify (fo);
 980         if (unified_ty->get_kind () == TyTy::TypeKind::ERROR)
 981           return;
 982
 983         fields.push_back (TyVar (unified_ty->get_ref ()));
 984       }
 985
 986     resolved = new TyTy::TupleType (type.get_ref (), type.get_ty_ref (),
 987                                     type.get_ident ().locus, fields);
 988   }
 989
 990   void visit (InferType &type) override
 991   {
 992     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
 993       {
 994         BaseRules::visit (type);
 995         return;
 996       }
 997
 998     resolved = base->clone ();
 999     resolved->set_ref (type.get_ref ());
1000   }
1001
1002 private:
1003   BaseType *get_base () override { return base; }
1004
1005   TupleType *base;
1006 };
1007
1008 class USizeRules : public BaseRules
1009 {
1010   using Rust::TyTy::BaseRules::visit;
1011
1012 public:
1013   USizeRules (USizeType *base) : BaseRules (base), base (base) {}
1014
1015   void visit (InferType &type) override
1016   {
1017     // cant assign a float inference variable
1018     if (type.get_infer_kind () == InferType::InferTypeKind::FLOAT)
1019       {
1020         BaseRules::visit (type);
1021         return;
1022       }
1023
1024     resolved = base->clone ();
1025     resolved->set_ref (type.get_ref ());
1026   }
1027
1028   void visit (USizeType &type) override { resolved = type.clone (); }
1029
1030 private:
1031   BaseType *get_base () override { return base; }
1032
1033   USizeType *base;
1034 };
1035
1036 class ISizeRules : public BaseRules
1037 {
1038   using Rust::TyTy::BaseRules::visit;
1039
1040 public:
1041   ISizeRules (ISizeType *base) : BaseRules (base), base (base) {}
1042
1043   void visit (InferType &type) override
1044   {
1045     // cant assign a float inference variable
1046     if (type.get_infer_kind () == InferType::InferTypeKind::FLOAT)
1047       {
1048         BaseRules::visit (type);
1049         return;
1050       }
1051
1052     resolved = base->clone ();
1053     resolved->set_ref (type.get_ref ());
1054   }
1055
1056   void visit (ISizeType &type) override { resolved = type.clone (); }
1057
1058 private:
1059   BaseType *get_base () override { return base; }
1060
1061   ISizeType *base;
1062 };
1063
1064 class CharRules : public BaseRules
1065 {
1066   using Rust::TyTy::BaseRules::visit;
1067
1068 public:
1069   CharRules (CharType *base) : BaseRules (base), base (base) {}
1070
1071   void visit (InferType &type) override
1072   {
1073     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
1074       {
1075         BaseRules::visit (type);
1076         return;
1077       }
1078
1079     resolved = base->clone ();
1080     resolved->set_ref (type.get_ref ());
1081   }
1082
1083   void visit (CharType &type) override { resolved = type.clone (); }
1084
1085 private:
1086   BaseType *get_base () override { return base; }
1087
1088   CharType *base;
1089 };
1090
1091 class ReferenceRules : public BaseRules
1092 {
1093   using Rust::TyTy::BaseRules::visit;
1094
1095 public:
1096   ReferenceRules (ReferenceType *base) : BaseRules (base), base (base) {}
1097
1098   void visit (ReferenceType &type) override
1099   {
1100     auto base_type = base->get_base ();
1101     auto other_base_type = type.get_base ();
1102
1103     TyTy::BaseType *base_resolved = base_type->unify (other_base_type);
1104     if (base_resolved == nullptr
1105         || base_resolved->get_kind () == TypeKind::ERROR)
1106       {
1107         BaseRules::visit (type);
1108         return;
1109       }
1110
1111     // rust is permissive about mutablity here you can always go from mutable to
1112     // immutable but not the otherway round
1113     bool mutability_ok = base->is_mutable () ? type.is_mutable () : true;
1114     if (!mutability_ok)
1115       {
1116         BaseRules::visit (type);
1117         return;
1118       }
1119
1120     resolved = new ReferenceType (base->get_ref (), base->get_ty_ref (),
1121                                   TyVar (base_resolved->get_ref ()),
1122                                   base->mutability ());
1123   }
1124
1125   void visit (InferType &type) override
1126   {
1127     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
1128       {
1129         BaseRules::visit (type);
1130         return;
1131       }
1132
1133     resolved = base->clone ();
1134     resolved->set_ref (type.get_ref ());
1135   }
1136
1137 private:
1138   BaseType *get_base () override { return base; }
1139
1140   ReferenceType *base;
1141 };
1142
1143 class PointerRules : public BaseRules
1144 {
1145   using Rust::TyTy::BaseRules::visit;
1146
1147 public:
1148   PointerRules (PointerType *base) : BaseRules (base), base (base) {}
1149
1150   void visit (PointerType &type) override
1151   {
1152     auto base_type = base->get_base ();
1153     auto other_base_type = type.get_base ();
1154
1155     TyTy::BaseType *base_resolved = base_type->unify (other_base_type);
1156     if (base_resolved == nullptr
1157         || base_resolved->get_kind () == TypeKind::ERROR)
1158       {
1159         BaseRules::visit (type);
1160         return;
1161       }
1162
1163     // rust is permissive about mutablity here you can always go from mutable to
1164     // immutable but not the otherway round
1165     bool mutability_ok = base->is_mutable () ? type.is_mutable () : true;
1166     if (!mutability_ok)
1167       {
1168         BaseRules::visit (type);
1169         return;
1170       }
1171
1172     resolved = new PointerType (base->get_ref (), base->get_ty_ref (),
1173                                 TyVar (base_resolved->get_ref ()),
1174                                 base->mutability ());
1175   }
1176
1177   void visit (InferType &type) override
1178   {
1179     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
1180       {
1181         BaseRules::visit (type);
1182         return;
1183       }
1184
1185     resolved = base->clone ();
1186     resolved->set_ref (type.get_ref ());
1187   }
1188
1189 private:
1190   BaseType *get_base () override { return base; }
1191
1192   PointerType *base;
1193 };
1194
1195 class ParamRules : public BaseRules
1196 {
1197   using Rust::TyTy::BaseRules::visit;
1198
1199 public:
1200   ParamRules (ParamType *base) : BaseRules (base), base (base) {}
1201
1202   // param types are a placeholder we shouldn't have cases where we unify
1203   // against it. eg: struct foo<T> { a: T }; When we invoke it we can do either:
1204   //
1205   // foo<i32>{ a: 123 }.
1206   // Then this enforces the i32 type to be referenced on the
1207   // field via an hirid.
1208   //
1209   // rust also allows for a = foo{a:123}; Where we can use an Inference Variable
1210   // to handle the typing of the struct
1211   BaseType *unify (BaseType *other) override final
1212   {
1213     if (!base->can_resolve ())
1214       return BaseRules::unify (other);
1215
1216     auto lookup = base->resolve ();
1217     return lookup->unify (other);
1218   }
1219
1220   void visit (ParamType &type) override
1221   {
1222     if (base->get_symbol ().compare (type.get_symbol ()) != 0)
1223       {
1224         BaseRules::visit (type);
1225         return;
1226       }
1227
1228     resolved = type.clone ();
1229   }
1230
1231   void visit (InferType &type) override
1232   {
1233     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
1234       {
1235         BaseRules::visit (type);
1236         return;
1237       }
1238
1239     resolved = base->clone ();
1240   }
1241
1242 private:
1243   BaseType *get_base () override { return base; }
1244
1245   ParamType *base;
1246 };
1247
1248 class StrRules : public BaseRules
1249 {
1250   // FIXME we will need a enum for the StrType like ByteBuf etc..
1251   using Rust::TyTy::BaseRules::visit;
1252
1253 public:
1254   StrRules (StrType *base) : BaseRules (base), base (base) {}
1255
1256   void visit (StrType &type) override { resolved = type.clone (); }
1257
1258 private:
1259   BaseType *get_base () override { return base; }
1260
1261   StrType *base;
1262 };
1263
1264 class NeverRules : public BaseRules
1265 {
1266   using Rust::TyTy::BaseRules::visit;
1267
1268 public:
1269   NeverRules (NeverType *base) : BaseRules (base), base (base) {}
1270
1271   void visit (NeverType &type) override { resolved = type.clone (); }
1272
1273 private:
1274   BaseType *get_base () override { return base; }
1275
1276   NeverType *base;
1277 };
1278
1279 class PlaceholderRules : public BaseRules
1280 {
1281   using Rust::TyTy::BaseRules::visit;
1282
1283 public:
1284   PlaceholderRules (PlaceholderType *base) : BaseRules (base), base (base) {}
1285
1286   BaseType *unify (BaseType *other) override final
1287   {
1288     if (!base->can_resolve ())
1289       return BaseRules::unify (other);
1290
1291     BaseType *lookup = base->resolve ();
1292     return lookup->unify (other);
1293   }
1294
1295   void visit (PlaceholderType &type) override
1296   {
1297     if (base->get_symbol ().compare (type.get_symbol ()) != 0)
1298       {
1299         BaseRules::visit (type);
1300         return;
1301       }
1302
1303     resolved = type.clone ();
1304   }
1305
1306   void visit (InferType &type) override
1307   {
1308     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
1309       {
1310         BaseRules::visit (type);
1311         return;
1312       }
1313
1314     resolved = base->clone ();
1315   }
1316
1317 private:
1318   BaseType *get_base () override { return base; }
1319
1320   PlaceholderType *base;
1321 };
1322
1323 class DynamicRules : public BaseRules
1324 {
1325   using Rust::TyTy::BaseRules::visit;
1326
1327 public:
1328   DynamicRules (DynamicObjectType *base) : BaseRules (base), base (base) {}
1329
1330   void visit (InferType &type) override
1331   {
1332     if (type.get_infer_kind () != InferType::InferTypeKind::GENERAL)
1333       {
1334         BaseRules::visit (type);
1335         return;
1336       }
1337
1338     resolved = base->clone ();
1339   }
1340
1341   void visit (DynamicObjectType &type) override
1342   {
1343     if (base->num_specified_bounds () != type.num_specified_bounds ())
1344       {
1345         BaseRules::visit (type);
1346         return;
1347       }
1348
1349     Location ref_locus = mappings->lookup_location (type.get_ref ());
1350     if (!base->bounds_compatible (type, ref_locus, true))
1351       {
1352         BaseRules::visit (type);
1353         return;
1354       }
1355
1356     resolved = base->clone ();
1357   }
1358
1359 private:
1360   BaseType *get_base () override { return base; }
1361
1362   DynamicObjectType *base;
1363 };
1364
1365 } // namespace TyTy
1366 } // namespace Rust
1367
1368 #endif // RUST_TYTY_RULES