Implicit Trait Constraints

[IGI-111]

CS-FSSA-011

In Sway, traits can define supertraits. This means that, to implement such a trait for a type, one must
implement its supertrait as well. For example, T2 is a supertrait of T1:

script;
trait T2 {}
trait T1: T2 {
 fn new() -> Self;
}
struct S {}
impl T2 for S {}
impl T1 for S {
 fn new() -> Self {
 S {}
 }
}
fn bar<T>() -> T
where
 T: T1,
{
 T::new()
}
fn foo<T>() -> T
where
 T: T2,
{
 bar()
}
fn main() {}

In the above example, let's focus on foo(). foo() is a generic function, whose type parameter T just
has to implement T2. In its implementation, foo() calls bar() and returns its result: type inference
therefore implies that the same type T should also parametrise the call to bar(). However, foo()
additionally requires that its type parameter implement T1: this constraint is not automatically satisfied for
all types T that implement T2, so compilation should fail. Instead, the program is accepted by the
compiler.
Taking this a step further, if one adds let s: S = foo(); to the main(), so as to actually trigger a
call to a non-existent function, the compiler runs into an ICE:
Internal compiler error: Method new_3 is a trait method dummy and was not properly replaced.
Please file an issue on the repository and include the code that triggered this error.
For reference, Rust prohibits the above snippet and requires to add an explicit trait bound T1 for foo().