Dynamic dispatch with supertraits

[liamnaddell]

There was only one function that needed modification, the rest is testing for this new feature :)

    gcc/rust/ChangeLog:

            * backend/rust-compile.cc:
            Modify compute_address_for_trait_item to support supertraits
            * typecheck/rust-tyty.cc:
            Remove auto

    gcc/testsuite/ChangeLog:

            * rust/compile/trait13.rs:
            Add test for supertraits of supertraits
            * rust/compile/trait14.rs:
            Diamond problem with supertraits test
            * rust/execute/torture/trait14.rs:
            Add test for dynamic dispatch with supertraits
            * rust/execute/torture/trait15.rs:
            Add test for dynamic dispatch with generics
            * rust/execute/torture/trait16.rs:
            Add test for dynamic dispatch with lifetime params 1
            * rust/execute/torture/trait17.rs:
            Add test for dynamic dispatch with lifetime params 2
            * rust/execute/torture/trait18.rs:
            Add test for default implementations with dynamic dispatch and
            supertraits

Fixes #914

• GCC development requires copyright assignment or the Developer's Certificate of Origin sign-off, see https://gcc.gnu.org/contribute.html or https://gcc.gnu.org/dco.html
• Read contributing guidlines
• make check-rust passes locally
• Run clang-format
• Added any relevant test cases to gcc/testsuite/rust/

---

Modifies compute_address_for_trait_item to support supertraits. The algorithm works by looping over receiver_bounds for all relevant traits, and attempting to find one that matches the type, and contains the correct function implementation.

[liamnaddell]

NOTE: I found a bug with the following code sample:

extern "C" {
    fn printf(s: *const i8, ...);
}

struct Foo {
    my_int: u32,
}

trait Parent {
    fn parent(&self) -> bool;
}

trait Child : Parent {
    fn child(&self);
}

impl Parent for Foo {
    fn parent(&self) -> bool {
        // Call supertrait method
        return true;
    }
}

impl Child for Foo {
    fn child(&self) {
        let _ = self;
    }
}

pub fn main() {
    let a = Foo{ my_int: 0xf00dfeed};
    let b: &dyn Child = &a;

    let c: &dyn Parent = b;

    c.parent();
}

I think this particular case might be best handled in a separate issue. Gating casts from dyn Child to dyn Parent seems like it will be quite involved. Also, out of scope of the original issue.

For context, the problem here is that you have to take Child's vtable, and prune it to match Parent's vtable. Rustc currently doesn't let you do this, however, they seem somewhat close-ish to stabilizing this conversion.

[P-E-P]

Looks good, great work. I like all those new tests.