cl: fix compileCompositeLitEx struct for sliceLit/mapLit

Author: visualfc

cl/compile_test.go

@@ -4193,3 +4193,34 @@ func main() {
 }
 `)
 }
+
+func TestCompositeLitEx(t *testing.T) {
+	gopClTest(t, `
+type T struct {
+	s  []any
+	m  map[any]any
+	fn func(int) int
+}
+
+echo &T{[10, 3.14, 200], {10: "A", 3.14: "B", 200: "C"}, (x => x)}
+echo &T{s: [10, 3.14, 200], m: {10: "A", 3.14: "B", 200: "C"}, fn: (x => x)}
+`, `package main
+
+import "fmt"
+
+type T struct {
+	s  []interface{}
+	m  map[interface{}]interface{}
+	fn func(int) int
+}
+
+func main() {
+	fmt.Println(&T{[]interface{}{10, 3.14, 200}, map[interface{}]interface{}{10: "A", 3.14: "B", 200: "C"}, func(x int) int {
+		return x
+	}})
+	fmt.Println(&T{s: []interface{}{10, 3.14, 200}, m: map[interface{}]interface{}{10: "A", 3.14: "B", 200: "C"}, fn: func(x int) int {
+		return x
+	}})
+}
+`)
+}

cl/expr.go

@@ -1091,6 +1091,34 @@ func compileCompositeLitElts(ctx *blockCtx, elts []ast.Expr, kind int, expected
 	}
 }
 
+func unparent(x ast.Expr) ast.Expr {
+	if e, ok := x.(*ast.ParenExpr); ok {
+		return e.X
+	}
+	return x
+}
+
+func compileStructLit(ctx *blockCtx, elts []ast.Expr, t *types.Struct, typ types.Type, src *ast.CompositeLit) error {
+	for idx, elt := range elts {
+		switch expr := unparent(elt).(type) {
+		case *ast.LambdaExpr, *ast.LambdaExpr2:
+			sig, err := checkLambdaFuncType(ctx, expr, t.Field(idx).Type(), clLambaField, elt)
+			if err != nil {
+				return err
+			}
+			compileLambda(ctx, expr, sig)
+		case *ast.SliceLit:
+			compileSliceLit(ctx, expr, t.Field(idx).Type())
+		case *ast.CompositeLit:
+			compileCompositeLit(ctx, expr, t.Field(idx).Type(), false)
+		default:
+			compileExpr(ctx, elt)
+		}
+	}
+	ctx.cb.StructLit(typ, len(elts), false, src)
+	return nil
+}
+
 func compileStructLitInKeyVal(ctx *blockCtx, elts []ast.Expr, t *types.Struct, typ types.Type, src *ast.CompositeLit) error {
 	for _, elt := range elts {
 		kv := elt.(*ast.KeyValueExpr)
@@ -1105,13 +1133,17 @@ func compileStructLitInKeyVal(ctx *blockCtx, elts []ast.Expr, t *types.Struct, t
 		if rec := ctx.recorder(); rec != nil {
 			rec.Use(name, t.Field(idx))
 		}
-		switch expr := kv.Value.(type) {
+		switch expr := unparent(kv.Value).(type) {
 		case *ast.LambdaExpr, *ast.LambdaExpr2:
 			sig, err := checkLambdaFuncType(ctx, expr, t.Field(idx).Type(), clLambaField, kv.Key)
 			if err != nil {
 				return err
 			}
 			compileLambda(ctx, expr, sig)
+		case *ast.SliceLit:
+			compileSliceLit(ctx, expr, t.Field(idx).Type())
+		case *ast.CompositeLit:
+			compileCompositeLit(ctx, expr, t.Field(idx).Type(), false)
 		default:
 			compileExpr(ctx, kv.Value)
 		}
@@ -1194,8 +1226,14 @@ func compileCompositeLitEx(ctx *blockCtx, v *ast.CompositeLit, expected types.Ty
 			typ, underlying = expected, tu
 		}
 	}
-	if t, ok := underlying.(*types.Struct); ok && kind == compositeLitKeyVal {
-		if err := compileStructLitInKeyVal(ctx, v.Elts, t, typ, v); err != nil {
+	if t, ok := underlying.(*types.Struct); ok {
+		var err error
+		if kind == compositeLitKeyVal {
+			err = compileStructLitInKeyVal(ctx, v.Elts, t, typ, v)
+		} else {
+			err = compileStructLit(ctx, v.Elts, t, typ, v)
+		}
+		if err != nil {
 			return err
 		}
 	} else {
@@ -1214,8 +1252,6 @@ func compileCompositeLitEx(ctx *blockCtx, v *ast.CompositeLit, expected types.Ty
 				ctx.cb.SliceLitEx(typ, n<<kind, kind == compositeLitKeyVal, v)
 			case *types.Array:
 				ctx.cb.ArrayLitEx(typ, n<<kind, kind == compositeLitKeyVal, v)
-			case *types.Struct:
-				ctx.cb.StructLit(typ, n, false, v) // key-val mode handled by compileStructLitInKeyVal
 			default:
 				return ctx.newCodeErrorf(v.Pos(), "invalid composite literal type %v", typ)
 			}

cl/stmt.go

@@ -295,7 +295,7 @@ func compileAssignStmt(ctx *blockCtx, expr *ast.AssignStmt) {
 		compileExprLHS(ctx, lhs)
 	}
 	for i, rhs := range expr.Rhs {
-		switch e := rhs.(type) {
+		switch e := unparent(rhs).(type) {
 		case *ast.LambdaExpr, *ast.LambdaExpr2:
 			if len(expr.Lhs) == 1 && len(expr.Rhs) == 1 {
 				typ := ctx.cb.Get(-1).Type.(interface{ Elem() types.Type }).Elem()