add new Clone API test case

Change-Id: I639df00ca5101d6287eb2c08e9fc9f8ce34fee02

Author: mateusz834

test/devirtualization_with_type_assertions_interleaved.go

@@ -10,8 +10,8 @@ type hashIface interface {
 	Sum() []byte
 }
 
-type clonableHashIface interface {
-	Sum() []byte
+type cloneableHashIface interface {
+	hashIface
 	Clone() hashIface
 }
 
@@ -42,42 +42,42 @@ func newHash() hashIface { // ERROR "can inline newHash$"
 }
 
 func cloneHash1(h hashIface) hashIface { // ERROR "can inline cloneHash1$" "leaking param: h$"
-	if h, ok := h.(clonableHashIface); ok {
+	if h, ok := h.(cloneableHashIface); ok {
 		return h.Clone()
 	}
 	return &hash{} // ERROR "&hash{} escapes to heap$"
 }
 
 func cloneHash2(h hashIface) hashIface { // ERROR "can inline cloneHash2$" "leaking param: h$"
-	if h, ok := h.(clonableHashIface); ok {
+	if h, ok := h.(cloneableHashIface); ok {
 		return h.Clone()
 	}
 	return nil
 }
 
 func cloneHash3(h hashIface) hashIface { // ERROR "can inline cloneHash3$" "leaking param: h$"
-	if h, ok := h.(clonableHashIface); ok {
+	if h, ok := h.(cloneableHashIface); ok {
 		return h.Clone()
 	}
 	return &hash2{} // ERROR "&hash2{} escapes to heap$"
 }
 
 func cloneHashWithBool1(h hashIface) (hashIface, bool) { // ERROR "can inline cloneHashWithBool1$" "leaking param: h$"
-	if h, ok := h.(clonableHashIface); ok {
+	if h, ok := h.(cloneableHashIface); ok {
 		return h.Clone(), true
 	}
 	return &hash{}, false // ERROR "&hash{} escapes to heap$"
 }
 
 func cloneHashWithBool2(h hashIface) (hashIface, bool) { // ERROR "can inline cloneHashWithBool2$" "leaking param: h$"
-	if h, ok := h.(clonableHashIface); ok {
+	if h, ok := h.(cloneableHashIface); ok {
 		return h.Clone(), true
 	}
 	return nil, false
 }
 
 func cloneHashWithBool3(h hashIface) (hashIface, bool) { // ERROR "can inline cloneHashWithBool3$" "leaking param: h$"
-	if h, ok := h.(clonableHashIface); ok {
+	if h, ok := h.(cloneableHashIface); ok {
 		return h.Clone(), true
 	}
 	return &hash2{}, false // ERROR "&hash2{} escapes to heap$"
@@ -105,3 +105,35 @@ func interleavedWithTypeAssertions() {
 	h7, _ := cloneHashWithBool3(h1) // ERROR "&hash2{} escapes to heap$" "devirtualizing h.Clone to \*hash$" "inlining call to \(\*hash\).Clone" "inlining call to cloneHashWithBool3" "moved to heap: c$"
 	_ = h7.Sum()
 }
+
+type cloneableHashError interface {
+	hashIface
+	Clone() (hashIface, error)
+}
+
+type hash3 struct{ state [32]byte }
+
+func newHash3() hashIface { // ERROR "can inline newHash3$"
+	return &hash3{} // ERROR "&hash3{} escapes to heap$"
+}
+
+func (h *hash3) Sum() []byte { // ERROR "can inline \(\*hash3\).Sum$" "h does not escape$"
+	return make([]byte, 32) // ERROR "make\(\[\]byte, 32\) escapes to heap$"
+}
+
+func (h *hash3) Clone() (hashIface, error) { // ERROR "can inline \(\*hash3\).Clone$" "h does not escape$"
+	c := *h // ERROR "moved to heap: c$"
+	return &c, nil
+}
+
+func interleavedCloneableHashError() {
+	h1 := newHash3() // ERROR "&hash3{} does not escape$" "inlining call to newHash3"
+	_ = h1.Sum()     // ERROR "devirtualizing h1.Sum to \*hash3$" "inlining call to \(\*hash3\).Sum" "make\(\[\]byte, 32\) does not escape$"
+
+	if h1, ok := h1.(cloneableHashError); ok {
+		h2, err := h1.Clone() // ERROR "devirtualizing h1.Clone to \*hash3$" "inlining call to \(\*hash3\).Clone"
+		if err == nil {
+			_ = h2.Sum() // ERROR "devirtualizing h2.Sum to \*hash3$" "inlining call to \(\*hash3\).Sum" "make\(\[\]byte, 32\) does not escape$"
+		}
+	}
+}