Make a generic trait that holds something that implements a separate trait?

I have a trait that makes sure whatever struct implements it holds specific data types so I can use those structs in any place where that trait is implemented,

trait HasShape{
    fn ref_vertices(&self) -> &Vec<Vertex>;
    fn ref_vbo(&self) -> &VertexBuffer<Vertex>;
    // Goes on for the rest of the trait
}

trait Drawable
{
    fn draw(&self, target: &Frame);
}

impl<T> Drawable for T
where T: HasShape
{
    fn draw(&self, target: &Frame) {
        let vertices = self.ref_vertices();
        // Use the fields on type that are required by HasShape
    }
}

And I have another trait that is similar however it needs to hold an object that implements HasShape as well as other fields

trait HasPos<T>
where
    T: HasShape
{
    fn ref_shape(&self) -> &T;
    fn ref_pos(&self) -> &Vector2f32;
    // Rest is the same style as HasShape
}

trait Manipulate<T>
where T: HasShape
{
    fn translate(&self, x: f32, y: f32);
    // Rest are similar functions that change the fields of HasPos
}

My question is, how do I implement HasShape for all types that have HasPos so I can use anything that implements HasPos in place of a HasShape object?
like this

impl<T: HasPos<T>> HasShape for T
where T: HasShape
{
    fn ref_vertices(&self) -> &Vec<Vertex>{
        self.ref_shape().ref_vertices()
    }
    // Every function in HasShape just gets the field from the object in HasPos
}

That way I can call functions from Drawable on any object that implements HasPos as well?

impl<T: HasPos<T>> HasShape for T
where T: HasShape

This doesn't make much sense; you are implementing HasShape for all types that already implement HasShape.

If I understand correctly, you want to auto-implement HasShape for all objects that already implement HasPos. If so, you actually have two generics; one for the object you want to implement HasShape for, and one for the nested type of HasPos.

The impl is a little weird with a generic that isn't actually part of the type, though, so you need to convert T of HasPos to an associated type, like so:

#![allow(unused_variables)]

use std::marker::PhantomData;

pub struct Frame;
pub struct Vertex;
pub struct VertexBuffer<B>(PhantomData<B>);
pub struct Vector2f32;

trait HasShape {
    fn ref_vertices(&self) -> &Vec<Vertex>;
    fn ref_vbo(&self) -> &VertexBuffer<Vertex>;
    // Goes on for the rest of the trait
}

trait Drawable {
    fn draw(&self, target: &Frame);
}

impl<T> Drawable for T
where
    T: HasShape,
{
    fn draw(&self, target: &Frame) {
        let vertices = self.ref_vertices();
        // Use the fields on type that are required by HasShape
    }
}

trait HasPos {
    type Shape: HasShape;

    fn ref_shape(&self) -> &Self::Shape;
    fn ref_pos(&self) -> &Vector2f32;
    // Rest is the same style as HasShape
}

trait Manipulate<T>
where
    T: HasShape,
{
    fn translate(&self, x: f32, y: f32);
    // Rest are similar functions that change the fields of HasPos
}

impl<T> HasShape for T
where
    T: HasPos,
{
    fn ref_vertices(&self) -> &Vec<Vertex> {
        self.ref_shape().ref_vertices()
    }

    fn ref_vbo(&self) -> &VertexBuffer<Vertex> {
        self.ref_shape().ref_vbo()
    }
}

Note that there is one caveat, though: Now you can never manually implement HasShape and HasPos for the same type.

struct MyType;

impl HasPos for MyType {
    type Shape = MyType;

    fn ref_shape(&self) -> &Self::Shape {
        todo!()
    }

    fn ref_pos(&self) -> &Vector2f32 {
        todo!()
    }
}

impl HasShape for MyType {
    fn ref_vertices(&self) -> &Vec<Vertex> {
        todo!()
    }

    fn ref_vbo(&self) -> &VertexBuffer<Vertex> {
        todo!()
    }
}

error[E0119]: conflicting implementations of trait `HasShape` for type `MyType`
  --> src/lib.rs:73:1
   |
46 | impl<T> HasShape for T
   | ---------------------- first implementation here
...
73 | impl HasShape for MyType {
   | ^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyType`

This also means that no HasShape can have itself as its HasPos type, because this will create an infinite recursion:

struct MyType;

impl HasPos for MyType {
    type Shape = MyType;

    fn ref_shape(&self) -> &Self::Shape {
        &self
    }

    fn ref_pos(&self) -> &Vector2f32 {
        todo!()
    }
}

fn main() {
    let x = MyType;
    x.ref_vertices();
}

thread 'main' has overflowed its stack
fatal runtime error: stack overflow
Aborted