generate slices.All

Author: ALTree

microsmith/expr.go

@@ -794,6 +794,17 @@ func (eb *ExprBuilder) CallFunction(v Variable, ct ...Type) *ast.CallExpr {
 			ce.Args = []ast.Expr{eb.VarOrLit(t1), eb.VarOrLit(t2)}
 		}
 
+	case "slices.All":
+		if len(ct) == 0 {
+			panic("slices.All needs additional type arg")
+		}
+		t := ArrayOf(ct[0])
+		if eb.Deepen() {
+			ce.Args = []ast.Expr{eb.Expr(t)}
+		} else {
+			ce.Args = []ast.Expr{eb.VarOrLit(t)}
+		}
+
 	default:
 		if f.Args == nil || f.Ret == nil {
 			panic("CallFunction: missing special handling for " + name)

microsmith/package.go

@@ -196,7 +196,7 @@ func (pb *PackageBuilder) File() *ast.File {
 		}
 	}
 
-	pkgs := []string{"sync/atomic", "math", "reflect", "strings", "unsafe"}
+	pkgs := []string{"sync/atomic", "math", "reflect", "strings", "unsafe", "slices"}
 	for _, p := range pkgs {
 		af.Decls = append(af.Decls, MakeImport(p))
 	}
@@ -308,44 +308,26 @@ func MakeImport(p string) *ast.GenDecl {
 }
 
 func MakeUsePakage(p string) *ast.GenDecl {
-	se := &ast.SelectorExpr{}
-	switch p {
-	case "unsafe":
-		// var _ = unsafe.Sizeof is not allowed, we need to call it.
-		return &ast.GenDecl{
-			Tok: token.VAR,
-			Specs: []ast.Spec{
-				&ast.ValueSpec{
-					Names: []*ast.Ident{&ast.Ident{Name: "_"}},
-					Values: []ast.Expr{&ast.CallExpr{
-						Fun: &ast.SelectorExpr{
-							X:   &ast.Ident{Name: "unsafe"},
-							Sel: &ast.Ident{Name: "Sizeof"},
-						},
-						Args: []ast.Expr{&ast.Ident{Name: "0"}},
-					}},
-				},
-			},
-		}
-	case "sync/atomic":
-		se.X = &ast.Ident{Name: "atomic"}
-		se.Sel = &ast.Ident{Name: "LoadInt32"}
-	default:
-		fs := map[string]string{
-			"math":    "Sqrt",
-			"strings": "Title",
-			"reflect": "DeepEqual",
-		}
-		se.X = &ast.Ident{Name: p}
-		se.Sel = &ast.Ident{Name: fs[p]}
+	m := map[string]struct{ p, f, v string }{
+		"unsafe":      {"unsafe", "Sizeof", "0"},
+		"sync/atomic": {"atomic", "LoadInt32", "nil"},
+		"slices":      {"slices", "All", "[]int{}"},
+		"math":        {"math", "Sqrt", "0"},
+		"strings":     {"strings", "Title", `""`},
+		"reflect":     {"reflect", "DeepEqual", "1,1"},
 	}
-
 	return &ast.GenDecl{
 		Tok: token.VAR,
 		Specs: []ast.Spec{
 			&ast.ValueSpec{
-				Names:  []*ast.Ident{&ast.Ident{Name: "_"}},
-				Values: []ast.Expr{se},
+				Names: []*ast.Ident{&ast.Ident{Name: "_"}},
+				Values: []ast.Expr{&ast.CallExpr{
+					Fun: &ast.SelectorExpr{
+						X:   &ast.Ident{Name: m[p].p},
+						Sel: &ast.Ident{Name: m[p].f},
+					},
+					Args: []ast.Expr{&ast.Ident{Name: m[p].v}},
+				}},
 			},
 		},
 	}

microsmith/stmt.go

@@ -514,42 +514,54 @@ func (sb *StmtBuilder) RangeStmt() *ast.RangeStmt {
 		e = f(BT{"int"})
 		k = sb.S.NewIdent(BT{"int"})
 	case 3: // func
-		ft := sb.pb.RandRangeableFuncType()
-		p, r := ft.MakeFieldLists(true, sb.funcp)
-
-		// add yield param to the scope
-		sb.S.AddVariable(p.List[0].Names[0], ft.Args[0])
-		sb.funcp++
-
-		// generate a body for the func
-		sb.depth++
-		var body *ast.BlockStmt
-		if sb.CanNest() {
-			old := sb.C.inLoop
-			sb.C.inLoop = false
-			body = sb.BlockStmt()
-			sb.C.inLoop = old
+
+		// 50/50 between generating a new Rangeable func type or a
+		// call to a function from the slices package.
+		if sb.R.Intn(2) == 0 {
+			t := sb.pb.RandType()
+			f := FuncType{N: "slices.All"}
+			e = sb.E.CallFunction(Variable{f, &ast.Ident{Name: f.N}}, t)
+			k = sb.S.NewIdent(BT{"int"})
+			v = sb.S.NewIdent(t)
 		} else {
-			body = &ast.BlockStmt{List: []ast.Stmt{sb.AssignStmt()}}
-		}
-		sb.depth--
 
-		e = &ast.FuncLit{
-			Type: &ast.FuncType{Params: p, Results: r},
-			Body: body,
-		}
+			ft := sb.pb.RandRangeableFuncType()
+			p, r := ft.MakeFieldLists(true, sb.funcp)
+
+			// add yield param to the scope
+			sb.S.AddVariable(p.List[0].Names[0], ft.Args[0])
+			sb.funcp++
 
-		// remove the yield param from the scope
-		sb.S.DeleteIdentByName(p.List[0].Names[0])
-		sb.funcp--
-
-		// declare the iteration variables if needed
-		switch args := ft.Args[0].(FuncType).Args; len(args) {
-		case 1:
-			k = sb.S.NewIdent(args[0])
-		case 2:
-			k = sb.S.NewIdent(args[0])
-			v = sb.S.NewIdent(args[1])
+			// generate a body for the func
+			sb.depth++
+			var body *ast.BlockStmt
+			if sb.CanNest() {
+				old := sb.C.inLoop
+				sb.C.inLoop = false
+				body = sb.BlockStmt()
+				sb.C.inLoop = old
+			} else {
+				body = &ast.BlockStmt{List: []ast.Stmt{sb.AssignStmt()}}
+			}
+			sb.depth--
+
+			e = &ast.FuncLit{
+				Type: &ast.FuncType{Params: p, Results: r},
+				Body: body,
+			}
+
+			// remove the yield param from the scope
+			sb.S.DeleteIdentByName(p.List[0].Names[0])
+			sb.funcp--
+
+			// declare the iteration variables if needed
+			switch args := ft.Args[0].(FuncType).Args; len(args) {
+			case 1:
+				k = sb.S.NewIdent(args[0])
+			case 2:
+				k = sb.S.NewIdent(args[0])
+				v = sb.S.NewIdent(args[1])
+			}
 		}
 	default:
 		panic("unreachable")