append3.go2

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// append3 illustrates the properties of a 3-type-parameter "append" variant.
//
// With a more advanced type-inference algorithm and a proper "assignable to"
// constraint, it could support inference for all of the same cases as the
// built-in "append" does today, plus a few others.
package main

import (
	"context"
	"fmt"
	"unsafe"
)

type sliceOf(type E) interface{ type []E }

// buggyAssignableTo simulates an “assignable to” type constraint using
// the closest available alternative (a 1-element type list, which works
// for a few defined types but not channel-directons or subinterfaces).
type buggyAssignableTo(type T) interface {
	type T
}

func append(type S sliceOf(T), T interface{}, T2 buggyAssignableTo(T))(s S, t ...T2) S {
	lens := len(s)
	tot := lens + len(t)
	if tot < 0 {
		panic("Append: cap out of range")
	}
	if tot > cap(s) {
		news := make([]T, tot, tot+tot/2)
		copy(news, s)
		s = news
	}
	s = s[:tot]
	for i, x := range t {
		// This is why buggyAssignableTo is buggy. 🙂
		p := unsafe.Pointer(&x)
		s[lens+i] = *(*T)(p)
	}
	return s
}

type Funcs []func()
type Cancels []context.CancelFunc
type Recv <-chan int

var (
	f           func()
	cancel      context.CancelFunc
	funcSlice   []func()
	cancelSlice []context.CancelFunc
	funcs       Funcs
	cancels     Cancels
	r           <-chan int
	recvSlice   []<-chan int
	R           Recv
	RecvSlice   []Recv
	b           chan int
	bidiSlice   []chan int
)

func main() {
	// cannot infer T (http://b/159049873)
	ff := append([]func(), func(), func())(funcSlice, f)
	fmt.Printf("append(%T, %T) = %T\n", funcSlice, f, ff)

	// cannot infer T (http://b/159049873)
	Ff := append(Funcs, func(), func())(funcs, f)
	fmt.Printf("append(%T, %T) = %T\n", funcs, f, Ff)

	// cannot infer T
	fc := append([]func(), func(), context.CancelFunc)(funcSlice, cancel)
	fmt.Printf("append(%T, %T) = %T\n", funcSlice, cancel, fc)

	// cannot infer T
	cf := append([]context.CancelFunc, context.CancelFunc, func())(cancelSlice, f)
	fmt.Printf("append(%T, %T) = %T\n", cancelSlice, f, cf)

	// cannot infer T
	Fc := append(Funcs, func(), context.CancelFunc)(funcs, cancel)
	fmt.Printf("append(%T, %T) = %T\n", funcs, cancel, Fc)

	// cannot infer T
	Cc := append(Cancels, context.CancelFunc, func())(cancels, f)
	fmt.Printf("append(%T, %T) = %T\n", cancels, f, Cc)

	// cannot infer T
	ffc := append([]func(), func(), context.CancelFunc)(funcSlice, f, cancel)
	fmt.Printf("append(%T, %T, %T) = %T\n", funcSlice, f, cancel, ffc)

	// cannot infer T (http://b/159049873)
	ff2 := append([]func(), func(), func())(funcSlice, funcSlice...)
	fmt.Printf("append(%T, %T...) = %T\n", funcSlice, funcSlice, ff2)

	// cannot infer T (http://b/159049873)
	FF2 := append(Funcs, func(), func())(funcs, funcs...)
	fmt.Printf("append(%T, %T...) = %T\n", funcs, funcs, FF2)

	// cannot infer T (http://b/159049873)
	Ff2 := append(Funcs, func(), func())(funcs, funcSlice...)
	fmt.Printf("append(%T, %T...) = %T\n", funcs, funcSlice, Ff2)

	// cannot infer T (http://b/159049873)
	fc2 := append([]func(), func(), context.CancelFunc)(funcSlice, cancelSlice...)
	fmt.Printf("append(%T, %T...) = %T\n", funcSlice, cancelSlice, fc2)

	// cannot infer T
	FC2 := append(Funcs, func(), context.CancelFunc)(funcs, cancels...)
	fmt.Printf("append(%T, %T...) = %T\n", funcs, cancels, FC2)

	// cannot infer T (http://b/159049873)
	rr := append([]<-chan int, <-chan int, <-chan int)(recvSlice, r)
	fmt.Printf("append(%T, %T) = %T\n", recvSlice, r, rr)

	// cannot infer T
	// chan int does not satisfy interface{type T} (chan int not found in <-chan int)
	rb := append([]<-chan int, <-chan int, <-chan int)(recvSlice, b)
	fmt.Printf("append(%T, %T) = %T\n", recvSlice, b, rb)

	// cannot infer T (http://b/159049873)
	RR := append([]Recv, Recv, Recv)(RecvSlice, R)
	fmt.Printf("append(%T, %T) = %T\n", RecvSlice, R, RR)

	// cannot infer T (http://b/159049873)
	// Recv does not satisfy interface{type T} (<-chan int not found in Recv)
	Rb := append([]Recv, Recv, Recv)(RecvSlice, b)
	fmt.Printf("append(%T, %T) = %T\n", RecvSlice, b, Rb)

	// cannot infer T
	rrb := append([]<-chan int, <-chan int, <-chan int)(recvSlice, r, b)
	fmt.Printf("append(%T, %T) = %T\n", recvSlice, b, rrb)

	// cannot infer T (http://b/159049873)
	rr2 := append([]<-chan int, <-chan int, <-chan int)(recvSlice, recvSlice...)
	fmt.Printf("append(%T, %T...) = %T\n", recvSlice, recvSlice, rr2)

	// cannot infer T (http://b/159049873)
	// chan int does not satisfy interface{type T} (chan int not found in <-chan int)
	// rb2 := append([]<-chan int, <-chan int, chan int)(recvSlice, bidiSlice...)
	// fmt.Printf("append(%T, %T...) = %T\n", recvSlice, bidiSlice, rb2)
}