Fixes ignored where clause. (#5799)

## Description

When we have a impl type parameter that has a method where clause, the
type
parameter in the namespace would not include the method where clause.

This fix shadows the impl type parameter with a new method type
parameter that
contains the where clause.

PartialEqWithEnginesContext is now used to pass down engines and other
variables in PartialEqWithEngines.
OrdWithEnginesContext is now used to pass down engines and other
variables in OrdWithEngines.
This allows us to pass the variable is_inside_trait_constraint and break
the infinite recursion when where clauses such as `T:MyTrait<T>` are
used.

Fixes #5735
Also fixes #5693 

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [x] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

---------

Co-authored-by: Sophie Dankel <47993817+sdankel@users.noreply.github.com>
Co-authored-by: Joshua Batty <joshpbatty@gmail.com>

Author: 3 people

sway-core/src/decl_engine/engine.rs

@@ -261,11 +261,17 @@ impl DeclEngine {
                         (
                             AssociatedItemDeclId::TraitFn(x_id),
                             AssociatedItemDeclId::TraitFn(curr_parent_id),
-                        ) => self.get(x_id).eq(&self.get(curr_parent_id), engines),
+                        ) => self.get(x_id).eq(
+                            &self.get(curr_parent_id),
+                            &PartialEqWithEnginesContext::new(engines),
+                        ),
                         (
                             AssociatedItemDeclId::Function(x_id),
                             AssociatedItemDeclId::Function(curr_parent_id),
-                        ) => self.get(x_id).eq(&self.get(curr_parent_id), engines),
+                        ) => self.get(x_id).eq(
+                            &self.get(curr_parent_id),
+                            &PartialEqWithEnginesContext::new(engines),
+                        ),
                         _ => false,
                     }) {
                         left_to_check.push_back(curr_parent.clone());

sway-core/src/decl_engine/ref.rs

@@ -196,8 +196,8 @@ where
     DeclEngine: DeclEngineIndex<T>,
     T: Named + Spanned + PartialEqWithEngines,
 {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
-        let decl_engine = engines.de();
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
+        let decl_engine = ctx.engines().de();
         let DeclRef {
             name: ln,
             id: lid,
@@ -216,7 +216,7 @@ where
             // temporarily omitted
             subst_list: _,
         } = other;
-        ln == rn && decl_engine.get(lid).eq(&decl_engine.get(rid), engines)
+        ln == rn && decl_engine.get(lid).eq(&decl_engine.get(rid), ctx)
     }
 }
 
@@ -243,18 +243,18 @@ where
 
 impl EqWithEngines for DeclRefMixedInterface {}
 impl PartialEqWithEngines for DeclRefMixedInterface {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
-        let decl_engine = engines.de();
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
+        let decl_engine = ctx.engines().de();
         match (&self.id, &other.id) {
             (InterfaceDeclId::Abi(self_id), InterfaceDeclId::Abi(other_id)) => {
                 let left = decl_engine.get(self_id);
                 let right = decl_engine.get(other_id);
-                self.name == other.name && left.eq(&right, engines)
+                self.name == other.name && left.eq(&right, ctx)
             }
             (InterfaceDeclId::Trait(self_id), InterfaceDeclId::Trait(other_id)) => {
                 let left = decl_engine.get(self_id);
                 let right = decl_engine.get(other_id);
-                self.name == other.name && left.eq(&right, engines)
+                self.name == other.name && left.eq(&right, ctx)
             }
             _ => false,
         }

sway-core/src/engine_threading.rs

@@ -107,7 +107,8 @@ impl<T: HashWithEngines> Hash for WithEngines<'_, T> {
 
 impl<T: PartialEqWithEngines> PartialEq for WithEngines<'_, T> {
     fn eq(&self, rhs: &Self) -> bool {
-        self.thing.eq(&rhs.thing, self.engines)
+        self.thing
+            .eq(&rhs.thing, &PartialEqWithEnginesContext::new(self.engines))
     }
 }
 
@@ -118,7 +119,10 @@ where
     T: PartialEqWithEngines,
 {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.thing.cmp(&other.thing, self.engines))
+        Some(
+            self.thing
+                .cmp(&other.thing, &OrdWithEnginesContext::new(self.engines)),
+        )
     }
 }
 
@@ -127,7 +131,8 @@ where
     T: EqWithEngines,
 {
     fn cmp(&self, other: &Self) -> Ordering {
-        self.thing.cmp(&other.thing, self.engines)
+        self.thing
+            .cmp(&other.thing, &OrdWithEnginesContext::new(self.engines))
     }
 }
 
@@ -246,30 +251,88 @@ impl<T: HashWithEngines> HashWithEngines for Box<T> {
 
 pub trait EqWithEngines: PartialEqWithEngines {}
 
+pub struct PartialEqWithEnginesContext<'a> {
+    engines: &'a Engines,
+    is_inside_trait_constraint: bool,
+}
+
+impl<'a> PartialEqWithEnginesContext<'a> {
+    pub(crate) fn new(engines: &'a Engines) -> Self {
+        Self {
+            engines,
+            is_inside_trait_constraint: false,
+        }
+    }
+
+    pub(crate) fn with_is_inside_trait_constraint(&self) -> Self {
+        Self {
+            is_inside_trait_constraint: true,
+            ..*self
+        }
+    }
+
+    pub(crate) fn engines(&self) -> &Engines {
+        self.engines
+    }
+
+    pub(crate) fn is_inside_trait_constraint(&self) -> bool {
+        self.is_inside_trait_constraint
+    }
+}
+
 pub trait PartialEqWithEngines {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool;
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool;
+}
+
+pub struct OrdWithEnginesContext<'a> {
+    engines: &'a Engines,
+    is_inside_trait_constraint: bool,
+}
+
+impl<'a> OrdWithEnginesContext<'a> {
+    pub(crate) fn new(engines: &'a Engines) -> Self {
+        Self {
+            engines,
+            is_inside_trait_constraint: false,
+        }
+    }
+
+    pub(crate) fn with_is_inside_trait_constraint(&self) -> Self {
+        Self {
+            is_inside_trait_constraint: true,
+            ..*self
+        }
+    }
+
+    pub(crate) fn engines(&self) -> &Engines {
+        self.engines
+    }
+
+    pub(crate) fn is_inside_trait_constraint(&self) -> bool {
+        self.is_inside_trait_constraint
+    }
 }
 
 pub trait OrdWithEngines {
-    fn cmp(&self, other: &Self, engines: &Engines) -> Ordering;
+    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> Ordering;
 }
 
 impl<T: EqWithEngines + ?Sized> EqWithEngines for &T {}
 impl<T: PartialEqWithEngines + ?Sized> PartialEqWithEngines for &T {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
-        (*self).eq(*other, engines)
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
+        (*self).eq(*other, ctx)
     }
 }
 impl<T: OrdWithEngines + ?Sized> OrdWithEngines for &T {
-    fn cmp(&self, other: &Self, engines: &Engines) -> Ordering {
-        (*self).cmp(*other, engines)
+    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> Ordering {
+        (*self).cmp(*other, ctx)
     }
 }
 
 impl<T: OrdWithEngines> OrdWithEngines for Option<T> {
-    fn cmp(&self, other: &Self, engines: &Engines) -> Ordering {
+    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> Ordering {
         match (self, other) {
-            (Some(x), Some(y)) => x.cmp(y, engines),
+            (Some(x), Some(y)) => x.cmp(y, ctx),
             (Some(_), None) => Ordering::Less,
             (None, Some(_)) => Ordering::Greater,
             (None, None) => Ordering::Equal,
@@ -278,40 +341,40 @@ impl<T: OrdWithEngines> OrdWithEngines for Option<T> {
 }
 
 impl<T: OrdWithEngines> OrdWithEngines for Box<T> {
-    fn cmp(&self, other: &Self, engines: &Engines) -> Ordering {
-        (**self).cmp(&(**other), engines)
+    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> Ordering {
+        (**self).cmp(&(**other), ctx)
     }
 }
 
 impl<T: EqWithEngines> EqWithEngines for Option<T> {}
 impl<T: PartialEqWithEngines> PartialEqWithEngines for Option<T> {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
         match (self, other) {
             (None, None) => true,
-            (Some(x), Some(y)) => x.eq(y, engines),
+            (Some(x), Some(y)) => x.eq(y, ctx),
             _ => false,
         }
     }
 }
 
 impl<T: EqWithEngines> EqWithEngines for Box<T> {}
 impl<T: PartialEqWithEngines> PartialEqWithEngines for Box<T> {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
-        (**self).eq(&(**other), engines)
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
+        (**self).eq(&(**other), ctx)
     }
 }
 
 impl<T: EqWithEngines> EqWithEngines for [T] {}
 impl<T: PartialEqWithEngines> PartialEqWithEngines for [T] {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
-        self.len() == other.len() && self.iter().zip(other.iter()).all(|(x, y)| x.eq(y, engines))
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
+        self.len() == other.len() && self.iter().zip(other.iter()).all(|(x, y)| x.eq(y, ctx))
     }
 }
 impl<T: OrdWithEngines> OrdWithEngines for [T] {
-    fn cmp(&self, other: &Self, engines: &Engines) -> Ordering {
+    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> Ordering {
         self.iter()
             .zip(other.iter())
-            .map(|(x, y)| x.cmp(y, engines))
+            .map(|(x, y)| x.cmp(y, ctx))
             .find(|o| o.is_ne())
             .unwrap_or_else(|| self.len().cmp(&other.len()))
     }

sway-core/src/ir_generation/function.rs

@@ -952,7 +952,10 @@ impl<'eng> FnCompiler<'eng> {
                 // Validate that the val_exp is of the right type. We couldn't do it
                 // earlier during type checking as the type arguments may not have been resolved.
                 let val_ty = engines.te().get_unaliased(val_exp.return_type);
-                if !val_ty.eq(&TypeInfo::RawUntypedPtr, engines) {
+                if !val_ty.eq(
+                    &TypeInfo::RawUntypedPtr,
+                    &PartialEqWithEnginesContext::new(engines),
+                ) {
                     return Err(CompileError::IntrinsicUnsupportedArgType {
                         name: kind.to_string(),
                         span,

sway-core/src/language/call_path.rs

@@ -8,7 +8,7 @@ use std::{
 use crate::{
     engine_threading::{
         DebugWithEngines, DisplayWithEngines, EqWithEngines, HashWithEngines, OrdWithEngines,
-        PartialEqWithEngines,
+        OrdWithEnginesContext, PartialEqWithEngines, PartialEqWithEnginesContext,
     },
     Engines, Ident, Namespace,
 };
@@ -40,18 +40,17 @@ impl HashWithEngines for CallPathTree {
 
 impl EqWithEngines for CallPathTree {}
 impl PartialEqWithEngines for CallPathTree {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
         let CallPathTree {
             qualified_call_path,
             children,
         } = self;
-        qualified_call_path.eq(&other.qualified_call_path, engines)
-            && children.eq(&other.children, engines)
+        qualified_call_path.eq(&other.qualified_call_path, ctx) && children.eq(&other.children, ctx)
     }
 }
 
 impl OrdWithEngines for CallPathTree {
-    fn cmp(&self, other: &Self, engines: &Engines) -> Ordering {
+    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> Ordering {
         let CallPathTree {
             qualified_call_path: l_call_path,
             children: l_children,
@@ -61,8 +60,8 @@ impl OrdWithEngines for CallPathTree {
             children: r_children,
         } = other;
         l_call_path
-            .cmp(r_call_path, engines)
-            .then_with(|| l_children.cmp(r_children, engines))
+            .cmp(r_call_path, ctx)
+            .then_with(|| l_children.cmp(r_children, ctx))
     }
 }
 
@@ -121,18 +120,17 @@ impl HashWithEngines for QualifiedCallPath {
 
 impl EqWithEngines for QualifiedCallPath {}
 impl PartialEqWithEngines for QualifiedCallPath {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
         let QualifiedCallPath {
             call_path,
             qualified_path_root,
         } = self;
-        call_path.eq(&other.call_path)
-            && qualified_path_root.eq(&other.qualified_path_root, engines)
+        call_path.eq(&other.call_path) && qualified_path_root.eq(&other.qualified_path_root, ctx)
     }
 }
 
 impl OrdWithEngines for QualifiedCallPath {
-    fn cmp(&self, other: &Self, engines: &Engines) -> Ordering {
+    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> Ordering {
         let QualifiedCallPath {
             call_path: l_call_path,
             qualified_path_root: l_qualified_path_root,
@@ -143,7 +141,7 @@ impl OrdWithEngines for QualifiedCallPath {
         } = other;
         l_call_path
             .cmp(r_call_path)
-            .then_with(|| l_qualified_path_root.cmp(r_qualified_path_root, engines))
+            .then_with(|| l_qualified_path_root.cmp(r_qualified_path_root, ctx))
     }
 }
 

sway-core/src/language/parsed/declaration/function.rs

@@ -46,12 +46,12 @@ pub struct FunctionParameter {
 
 impl EqWithEngines for FunctionParameter {}
 impl PartialEqWithEngines for FunctionParameter {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
         self.name == other.name
             && self.is_reference == other.is_reference
             && self.is_mutable == other.is_mutable
             && self.mutability_span == other.mutability_span
-            && self.type_argument.eq(&other.type_argument, engines)
+            && self.type_argument.eq(&other.type_argument, ctx)
     }
 }
 

sway-core/src/language/parsed/declaration/trait.rs

@@ -47,7 +47,7 @@ impl Spanned for Supertrait {
 
 impl EqWithEngines for Supertrait {}
 impl PartialEqWithEngines for Supertrait {
-    fn eq(&self, other: &Self, engines: &Engines) -> bool {
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
         let Supertrait {
             name: ln,
             decl_ref: ldr,
@@ -56,7 +56,7 @@ impl PartialEqWithEngines for Supertrait {
             name: rn,
             decl_ref: rdr,
         } = other;
-        ln == rn && ldr.eq(rdr, engines)
+        ln == rn && ldr.eq(rdr, ctx)
     }
 }