Merge pull request #570 from xushiwei/q

tuple type: cb.tryUnpackTuple(auto unpacking)

Author: xushiwei

ast.go

@@ -1099,7 +1099,7 @@ func matchFuncType(
 	}
 	var t *types.Tuple
 	n := len(args)
-	if len(args) == 1 && checkTuple(&t, args[0].Type) {
+	if len(args) == 1 && checkTuple(&t, args[0].Type) { // TODO(xsw): tuple type
 		n = t.Len()
 		args = make([]*internal.Elem, n)
 		for i := 0; i < n; i++ {

type_tuple.go

@@ -15,6 +15,7 @@ package gogen
 
 import (
 	"go/ast"
+	"go/token"
 	"go/types"
 	"strconv"
 )
@@ -103,6 +104,55 @@ func (p *tupleFields) FieldRef(cb *CodeBuilder, t *types.Struct, name string, x
 	return false
 }
 
+func (p *CodeBuilder) checkTupleType(typ types.Type) (*tupleFields, bool) {
+	switch typ := typ.(type) {
+	case *types.Struct:
+		if vft, ok := p.vfts[typ]; ok {
+			return vft, true
+		}
+	case *types.Named:
+		if u, ok := typ.Underlying().(*types.Struct); ok {
+			if vft, ok := p.vfts[u]; ok {
+				return vft, true
+			}
+		}
+	}
+	return nil, false
+}
+
+func (p *CodeBuilder) tryUnpackTuple() int {
+	e := p.stk.Get(-1)
+	tuple := e.Type
+	if t, ok := p.checkTupleType(tuple); ok {
+		n := len(t.fields)
+		p.stk.PopN(1)
+		val := e.Val
+		if _, ok := val.(*ast.Ident); ok {
+			for i := 0; i < n; i++ {
+				p.stk.Push(e)
+				p.MemberVal(tupleFieldName(i))
+			}
+			return n
+		} else {
+			pkg := p.pkg
+			pkgType := pkg.Types
+			arg := types.NewParam(token.NoPos, pkgType, "v", tuple)
+			result := make([]*types.Var, n)
+			for i, fld := range t.fields {
+				result[i] = types.NewParam(token.NoPos, pkgType, "", fld.Type())
+			}
+			p.NewClosure(types.NewTuple(arg), types.NewTuple(result...), false).BodyStart(pkg)
+			for i := 0; i < n; i++ {
+				p.Val(arg).MemberVal(tupleFieldName(i))
+			}
+			p.Return(n).End()
+			p.stk.Push(e)
+			p.Call(1)
+		}
+	}
+	return 1
+}
+
 // LookupField looks up a field by name in the given struct type t.
 // It returns the field index if found, or -1 if not found.
 // It checks both the original fields and the virtual fields (e.g. tuple

type_tuple_test.go

@@ -26,14 +26,24 @@ func TestTupleMember(t *testing.T) {
 	x := types.NewField(token.NoPos, pkg.Types, "x", types.Typ[types.Int], false)
 	y := types.NewField(token.NoPos, pkg.Types, "y", types.Typ[types.Int], false)
 	typ := pkg.NewTuple(true, x, y)
+	pt := types.NewNamed(types.NewTypeName(token.NoPos, pkg.Types, "Point", typ), typ, nil)
 	a := types.NewParam(token.NoPos, pkg.Types, "a", typ)
-	pkg.NewFunc(nil, "foo", types.NewTuple(a), nil, false).BodyStart(pkg).
+	b := types.NewParam(token.NoPos, pkg.Types, "b", pt)
+	typf := types.NewSignatureType(nil, nil, nil, nil, types.NewTuple(b), false)
+	f := types.NewParam(token.NoPos, pkg.Types, "f", typf)
+	pkg.NewFunc(nil, "foo", types.NewTuple(a, f), nil, false).BodyStart(pkg).
 		Val(ctxRef(pkg, "a")).
 		MemberRef("x").
 		Val(ctxRef(pkg, "a")).
 		MemberVal("y").
 		Assign(1).
 		EndStmt().
+		DefineVarStart(token.NoPos, "x", "y").
+		Val(ctxRef(pkg, "a")).
+		EndInit(1).
+		DefineVarStart(token.NoPos, "x2", "y2").
+		Val(ctxRef(pkg, "f")).Call(0).
+		EndInit(1).
 		Debug(func(cb *gogen.CodeBuilder) {
 			cb.Val(ctxRef(pkg, "a"))
 			cb.Member("unknown", gogen.MemberFlagRef)
@@ -46,8 +56,12 @@ func TestTupleMember(t *testing.T) {
 func foo(a struct {
 	X_0 int
 	X_1 int
-}) {
+}, f func() (b Point)) {
 	a.X_0 = a.X_1
+	x, y := a.X_0, a.X_1
+	x2, y2 := func(v Point) (int, int) {
+		return v.X_0, v.X_1
+	}(f())
 }
 `)
 }

type_var_and_const.go

@@ -329,9 +329,10 @@ func checkTuple(t **types.Tuple, typ types.Type) (ok bool) {
 }
 
 func (p *ValueDecl) endInit(cb *CodeBuilder, arity int) *ValueDecl {
-	var t *types.Tuple
-	var values []ast.Expr
 	n := len(p.names)
+	if arity == 1 && n > 1 {
+		arity = cb.tryUnpackTuple()
+	}
 	rets := cb.stk.GetArgs(arity)
 	defer func() {
 		cb.stk.PopN(arity)
@@ -340,6 +341,8 @@ func (p *ValueDecl) endInit(cb *CodeBuilder, arity int) *ValueDecl {
 			cb.commitStmt(p.at) // to support inline call, we must emitStmt at EndInit stage
 		}
 	}()
+	var t *types.Tuple
+	var values []ast.Expr
 	if arity == 1 && checkTuple(&t, rets[0].Type) {
 		if n != t.Len() {
 			caller := getCaller(rets[0])