Reuse function with return type always equal to the struct that is calling that function in golang

I'm trying to do in Golang something that would be easily done in Java with Type. For example:

public class MyClass<Type extends MyClass<Type>> {
    public Type myMethod() {
        // Do something
        return (Type) this;
    }
}


public class Test1 extends MyClass<Test1> {
    public String A;
    
    Test1(String A) {
        this.A = A;
    }
}

public class Test2 extends MyClass<Test2> {
    public String B;

    Test2(String B) {
        this.B = B;
    }
}

So, in main I can do

Test1 t1 = new Test1("hello");
Test2 t2 = new Test2("world");
System.out.println(t1.myMethod().A); // Prints "hello"
System.out.println(t2.myMethod().B); // Prints "world"

I'm trying to figure out if there is a way to do somethig similar in Go.
Maybe something like:

type test1 struct {
	A string
}

type test2 struct {
	B string
}


func (val Type) MyMethod() Type {
	// Do something
	return val
}


func main() {
	t1 := test1{A: "hello"}
	t2 := test2{B: "world"}
	fmt.Println(t1.MyMethod().A) // Prints "hello"
	fmt.Println(t2.MyMethod().B) // Prints "world"
}

Thanks to JimB I found a way.

From Go 1.18 Generic Types are sypported.

So the Java MyClass will look something like this in Go:

type MyGeneric[T any] struct {
	self *T
}

func (val MyGeneric[T]) MyMethod() *T {
	// Do something
	return val.self
}

The Java class Test1 will be:

type test1 struct {
	MyGeneric[test1]
	A string
}

func MakeTest1(A string) test1 {
	answer := test1{A: A}
	answer.self = &answer
	return answer
}

And similarly the Java class Test2:

type test2 struct {
	MyGeneric[test2]
	B string
}

func MakeTest2(B string) test2 {
	answer := test2{B: B}
	answer.self = &answer
	return answer
}

So the main is as we wanted

t1 := MakeTest1("hello")
t2 := MakeTest2("world")
fmt.Println(t1.MyMethod().A) // Prints "hello"
fmt.Println(t2.MyMethod().B) // Prints "world"