--- /dev/null
+package main
+
+/*
+Large uncovered parts are:
+- methods
+- type assignability and identity
+- consts
+- interfaces, types implementing interfaces, type assertions
+- ... parameters
+*/
+
+import (
+ "bufio"
+ "fmt"
+ "math/rand"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+type Smith struct {
+ curPackage int
+ curBlock *Block
+ curBlockPos int
+ curFunc *Func
+
+ packages [NPackages]*Package
+
+ idSeq int
+ typeDepth int
+ stmtCount int
+ exprDepth int
+ exprCount int
+ totalExprCount int
+
+ predefinedTypes []*Type
+ stringType *Type
+ boolType *Type
+ intType *Type
+ byteType *Type
+ efaceType *Type
+ runeType *Type
+ float32Type *Type
+ float64Type *Type
+ complex64Type *Type
+ complex128Type *Type
+
+ statements []func()
+ expressions []func(res *Type) string
+
+ rng *rand.Rand
+}
+
+const (
+ NPackages = 3
+ NFiles = 3
+
+ NStatements = 10
+ NExprDepth = 4
+ NExprCount = 10
+ NTotalExprCount = 50
+
+/*
+ NStatements = 30
+ NExprDepth = 6
+ NExprCount = 20
+ NTotalExprCount = 1000
+*/
+)
+
+type Package struct {
+ name string
+ imports map[string]bool
+ top *Block
+
+ undefFuncs []*Func
+ undefVars []*Var
+
+ toplevVars []*Var
+ toplevFuncs []*Func
+}
+
+type Block struct {
+ str string
+ parent *Block
+ subBlock *Block
+ extendable bool
+ isBreakable bool
+ isContinuable bool
+ funcBoundary bool
+ sub []*Block
+ consts []*Const
+ types []*Type
+ funcs []*Func
+ vars []*Var
+}
+
+type Func struct {
+ name string
+ args []*Type
+ rets []*Type
+}
+
+type Var struct {
+ id string
+ typ *Type
+ block *Block
+ used bool
+}
+
+type Const struct {
+}
+
+func (smith *Smith) writeProgram(dir string) {
+ smith.initTypes()
+ smith.initExpressions()
+ smith.initStatements()
+ smith.initProgram()
+ for pi := range smith.packages {
+ smith.genPackage(pi)
+ }
+ smith.serializeProgram(dir)
+}
+
+func (smith *Smith) initProgram() {
+ smith.packages[0] = smith.newPackage("main")
+ smith.packages[0].undefFuncs = []*Func{
+ {name: "init", args: []*Type{}, rets: []*Type{}},
+ {name: "init", args: []*Type{}, rets: []*Type{}},
+ {name: "main", args: []*Type{}, rets: []*Type{}},
+ }
+ if !*singlepkg {
+ smith.packages[1] = smith.newPackage("a")
+ smith.packages[2] = smith.newPackage("b")
+ }
+}
+
+func (smith *Smith) newPackage(name string) *Package {
+ return &Package{name: name, imports: make(map[string]bool), top: &Block{extendable: true}}
+}
+
+func (smith *Smith) genPackage(pi int) {
+ smith.typeDepth = 0
+ smith.stmtCount = 0
+ smith.exprDepth = 0
+ smith.exprCount = 0
+ smith.totalExprCount = 0
+
+ p := smith.packages[pi]
+ if p == nil {
+ return
+ }
+ for len(p.undefFuncs) != 0 || len(p.undefVars) != 0 {
+ if len(p.undefFuncs) != 0 {
+ f := p.undefFuncs[len(p.undefFuncs)-1]
+ p.undefFuncs = p.undefFuncs[:len(p.undefFuncs)-1]
+ smith.genToplevFunction(pi, f)
+ }
+ if len(p.undefVars) != 0 {
+ v := p.undefVars[len(p.undefVars)-1]
+ p.undefVars = p.undefVars[:len(p.undefVars)-1]
+ smith.genToplevVar(pi, v)
+ }
+ }
+}
+
+func F(f string, args ...interface{}) string {
+ return fmt.Sprintf(f, args...)
+}
+
+func (smith *Smith) line(f string, args ...interface{}) {
+ s := F(f, args...)
+ b := &Block{parent: smith.curBlock, str: s}
+ if smith.curBlockPos+1 == len(smith.curBlock.sub) {
+ smith.curBlock.sub = append(smith.curBlock.sub, b)
+ } else {
+ smith.curBlock.sub = append(smith.curBlock.sub, nil)
+ copy(smith.curBlock.sub[smith.curBlockPos+2:], smith.curBlock.sub[smith.curBlockPos+1:])
+ smith.curBlock.sub[smith.curBlockPos+1] = b
+ }
+ smith.curBlockPos++
+}
+
+func (smith *Smith) resetContext(pi int) {
+ smith.curPackage = pi
+ p := smith.packages[pi]
+ smith.curBlock = p.top
+ smith.curBlockPos = len(smith.curBlock.sub) - 1
+ smith.curFunc = nil
+}
+
+func (smith *Smith) genToplevFunction(pi int, f *Func) {
+ smith.resetContext(pi)
+ smith.curFunc = f
+ smith.enterBlock(true)
+ smith.enterBlock(true)
+ argIds := make([]string, len(f.args))
+ argStr := ""
+ for i, a := range f.args {
+ argIds[i] = smith.newId("Param")
+ if i != 0 {
+ argStr += ", "
+ }
+ argStr += argIds[i] + " " + a.id
+ }
+ smith.line("func %v(%v)%v {", f.name, argStr, fmtTypeList(f.rets, false))
+ for i, a := range f.args {
+ smith.defineVar(argIds[i], a)
+ }
+ smith.curBlock.funcBoundary = true
+ smith.genBlock()
+ smith.leaveBlock()
+ smith.stmtReturn()
+ smith.line("}")
+ smith.leaveBlock()
+ if f.name != "init" {
+ smith.packages[smith.curPackage].toplevFuncs = append(smith.packages[smith.curPackage].toplevFuncs, f)
+ }
+}
+
+func (smith *Smith) genToplevVar(pi int, v *Var) {
+ smith.resetContext(pi)
+ smith.enterBlock(true)
+ smith.line("var %v = %v", v.id, smith.rvalue(v.typ))
+ smith.leaveBlock()
+ smith.packages[smith.curPackage].toplevVars = append(smith.packages[smith.curPackage].toplevVars, v)
+}
+
+func (smith *Smith) genBlock() {
+ smith.enterBlock(false)
+ for smith.rnd(10) != 0 {
+ smith.genStatement()
+ }
+ smith.leaveBlock()
+}
+
+func (smith *Smith) serializeProgram(dir string) {
+ for _, p := range smith.packages {
+ if p == nil {
+ continue
+ }
+ path := filepath.Join(dir, "src", p.name)
+ os.MkdirAll(path, os.ModePerm)
+ nf := NFiles
+ if *singlefile {
+ nf = 1
+ }
+ files := make([]*bufio.Writer, nf)
+ for i := range files {
+ fname := filepath.Join(path, fmt.Sprintf("%v.go", i))
+ f, err := os.Create(fname)
+ if err != nil {
+ fmt.Fprintf(os.Stdout, "failed to create a file: %v\n", err)
+ os.Exit(1)
+ }
+ w := bufio.NewWriter(bufio.NewWriter(f))
+ files[i] = w
+ defer func() {
+ w.Flush()
+ f.Close()
+ }()
+ fmt.Fprintf(w, "package %s\n", p.name)
+ for imp := range p.imports {
+ fmt.Fprintf(w, "import \"%s\"\n", imp)
+ }
+ if i == 0 && p.name == "main" {
+ fmt.Fprintf(w, "import \"runtime\"\n")
+ fmt.Fprintf(w, "func init() {\n")
+ fmt.Fprintf(w, " go func() {\n")
+ fmt.Fprintf(w, " for {\n")
+ fmt.Fprintf(w, " runtime.GC()\n")
+ fmt.Fprintf(w, " runtime.Gosched()\n")
+ fmt.Fprintf(w, " }\n")
+ fmt.Fprintf(w, " }()\n")
+ fmt.Fprintf(w, "}\n")
+ }
+ for imp := range p.imports {
+ fmt.Fprintf(w, "var _ = %s.UsePackage\n", imp)
+ }
+ if i == 0 {
+ fmt.Fprintf(w, "var UsePackage = 0\n")
+ fmt.Fprintf(w, "var SINK interface{}\n")
+ }
+ }
+ for _, decl := range p.top.sub {
+ serializeBlock(files[smith.rnd(len(files))], decl, 0)
+ }
+ }
+
+ path := filepath.Join(dir, "src", "a")
+ os.MkdirAll(path, os.ModePerm)
+ fname := filepath.Join(path, "0_test.go")
+ f, err := os.Create(fname)
+ if err != nil {
+ fmt.Fprintf(os.Stdout, "failed to create a file: %v\n", err)
+ os.Exit(1)
+ }
+ f.Write([]byte("package a\n"))
+ f.Close()
+}
+
+func serializeBlock(w *bufio.Writer, b *Block, d int) {
+ if true {
+ if b.str != "" {
+ w.WriteString(b.str)
+ w.WriteString("\n")
+ }
+ } else {
+ w.WriteString("/*" + strings.Repeat("*", d) + "*/ ")
+ w.WriteString(b.str)
+ w.WriteString(F(" // ext=%v vars=%v types=%v", b.extendable, len(b.vars), len(b.types)))
+ w.WriteString("\n")
+ }
+ for _, b1 := range b.sub {
+ serializeBlock(w, b1, d+1)
+ }
+}
+
+func (smith *Smith) vars() []*Var {
+ var vars []*Var
+ vars = append(vars, smith.packages[smith.curPackage].toplevVars...)
+ var f func(b *Block, pos int)
+ f = func(b *Block, pos int) {
+ for _, b1 := range b.sub[:pos+1] {
+ vars = append(vars, b1.vars...)
+ }
+ if b.parent != nil {
+ pos := len(b.parent.sub) - 1
+ if b.subBlock != nil {
+ pos = -2
+ for i, b1 := range b.parent.sub {
+ if b1 == b.subBlock {
+ pos = i
+ break
+ }
+ }
+ if pos == -2 {
+ panic("bad")
+ }
+ }
+ f(b.parent, pos)
+ }
+ }
+ f(smith.curBlock, smith.curBlockPos)
+ return vars
+}
+
+func (smith *Smith) types() []*Type {
+ var types []*Type
+ types = append(types, smith.predefinedTypes...)
+ var f func(b *Block, pos int)
+ f = func(b *Block, pos int) {
+ for _, b1 := range b.sub[:pos+1] {
+ types = append(types, b1.types...)
+ }
+ if b.parent != nil {
+ pos := len(b.parent.sub) - 1
+ if b.subBlock != nil {
+ pos = -2
+ for i, b1 := range b.parent.sub {
+ if b1 == b.subBlock {
+ pos = i
+ break
+ }
+ }
+ if pos == -2 {
+ panic("bad")
+ }
+ }
+ f(b.parent, pos)
+ }
+ }
+ f(smith.curBlock, smith.curBlockPos)
+ return types
+}
+
+func (smith *Smith) defineVar(id string, t *Type) {
+ v := &Var{id: id, typ: t, block: smith.curBlock}
+ b := smith.curBlock.sub[smith.curBlockPos]
+ b.vars = append(b.vars, v)
+}
+
+func (smith *Smith) defineType(t *Type) {
+ b := smith.curBlock.sub[smith.curBlockPos]
+ b.types = append(b.types, t)
+}
+
+func (smith *Smith) materializeVar(t *Type) string {
+ // TODO: generate var in another package
+ id := smith.newId("Var")
+ curBlock0 := smith.curBlock
+ curBlockPos0 := smith.curBlockPos
+ curBlockLen0 := len(smith.curBlock.sub)
+ exprDepth0 := smith.exprDepth
+ exprCount0 := smith.exprCount
+ smith.exprDepth = 0
+ smith.exprCount = 0
+ defer func() {
+ if smith.curBlock == curBlock0 {
+ curBlockPos0 += len(smith.curBlock.sub) - curBlockLen0
+ }
+ smith.curBlock = curBlock0
+ smith.curBlockPos = curBlockPos0
+ smith.exprDepth = exprDepth0
+ smith.exprCount = exprCount0
+ }()
+loop:
+ for {
+ if smith.curBlock.parent == nil {
+ break
+ }
+ if !smith.curBlock.extendable || smith.curBlockPos < 0 {
+ if smith.curBlock.subBlock == nil {
+ smith.curBlockPos = len(smith.curBlock.parent.sub) - 2
+ } else {
+ smith.curBlockPos = -2
+ for i, b1 := range smith.curBlock.parent.sub {
+ if b1 == smith.curBlock.subBlock {
+ smith.curBlockPos = i
+ break
+ }
+ }
+ if smith.curBlockPos == -2 {
+ panic("bad")
+ }
+ }
+ smith.curBlock = smith.curBlock.parent
+ continue
+ }
+ if smith.rnd(3) == 0 {
+ break
+ }
+ if smith.curBlockPos >= 0 {
+ b := smith.curBlock.sub[smith.curBlockPos]
+ for _, t1 := range b.types {
+ if dependsOn(t, t1) {
+ break loop
+ }
+ }
+ }
+ smith.curBlockPos--
+ }
+ if smith.curBlock.parent == nil {
+ for i := smith.curPackage; i < NPackages; i++ {
+ if smith.rndBool() || i == NPackages-1 || *singlepkg {
+ if i == smith.curPackage {
+ // emit global var into the current package
+ smith.enterBlock(true)
+ smith.line("var %v = %v", id, smith.rvalue(t))
+ smith.packages[smith.curPackage].toplevVars = append(smith.packages[smith.curPackage].toplevVars, &Var{id: id, typ: t})
+ smith.leaveBlock()
+ } else {
+ // emit global var into another package
+ smith.packages[i].undefVars = append(smith.packages[i].undefVars, &Var{id: id, typ: t})
+ smith.packages[smith.curPackage].imports[smith.packages[i].name] = true
+ id = smith.packages[i].name + "." + id
+ }
+ break
+ }
+ }
+ } else {
+ // emit local var
+ smith.line("%v := %v", id, smith.rvalue(t))
+ smith.defineVar(id, t)
+ }
+ return id
+}
+
+func (smith *Smith) materializeFunc(rets []*Type) *Func {
+ f := &Func{name: smith.newId("Func"), args: smith.atypeList(TraitGlobal), rets: rets}
+
+ curBlock0 := smith.curBlock
+ curBlockPos0 := smith.curBlockPos
+ curFunc0 := smith.curFunc
+ exprDepth0 := smith.exprDepth
+ exprCount0 := smith.exprCount
+ smith.exprDepth = 0
+ smith.exprCount = 0
+ defer func() {
+ smith.curBlock = curBlock0
+ smith.curBlockPos = curBlockPos0
+ smith.curFunc = curFunc0
+ smith.exprDepth = exprDepth0
+ smith.exprCount = exprCount0
+ }()
+
+ if smith.rndBool() && !*singlepkg && smith.curPackage != NPackages-1 {
+ for _, r1 := range rets {
+ if dependsOn(r1, nil) {
+ goto thisPackage
+ }
+ }
+ for _, t := range f.args {
+ if dependsOn(t, nil) {
+ goto thisPackage
+ }
+ }
+ // emit global var into another package
+ newF := new(Func)
+ *newF = *f
+ smith.packages[smith.curPackage+1].undefFuncs = append(smith.packages[smith.curPackage+1].undefFuncs, newF)
+ smith.packages[smith.curPackage].imports[smith.packages[smith.curPackage+1].name] = true
+ f.name = smith.packages[smith.curPackage+1].name + "." + f.name
+ return f
+ }
+thisPackage:
+ smith.genToplevFunction(smith.curPackage, f)
+ return f
+}
+
+func (smith *Smith) materializeGotoLabel() string {
+ // TODO: move lavel up
+ id := smith.newId("Label")
+
+ curBlock0 := smith.curBlock
+ curBlockPos0 := smith.curBlockPos
+ curBlockLen0 := len(smith.curBlock.sub)
+ defer func() {
+ if smith.curBlock == curBlock0 {
+ curBlockPos0 += len(smith.curBlock.sub) - curBlockLen0
+ }
+ smith.curBlock = curBlock0
+ smith.curBlockPos = curBlockPos0
+ }()
+
+ for {
+ if smith.curBlock.parent.funcBoundary && smith.curBlockPos <= 0 {
+ break
+ }
+ if !smith.curBlock.extendable || smith.curBlockPos < 0 {
+ if smith.curBlock.subBlock != nil {
+ // we should have been stopped at func boundary
+ panic("bad")
+ }
+ smith.curBlock = smith.curBlock.parent
+ smith.curBlockPos = len(smith.curBlock.sub) - 2
+ continue
+ }
+ if smith.rnd(3) == 0 {
+ break
+ }
+ smith.curBlockPos--
+ }
+
+ smith.line("%v:", id)
+ return id
+}
+
+func (smith *Smith) rnd(n int) int {
+ return smith.rng.Intn(n)
+}
+
+func (smith *Smith) rndBool() bool {
+ return smith.rnd(2) == 0
+}
+
+func (smith *Smith) choice(ch ...string) string {
+ return ch[smith.rnd(len(ch))]
+}
+
+func (smith *Smith) newId(prefix string) string {
+ if prefix[0] < 'A' || prefix[0] > 'Z' {
+ panic("unexported id")
+ }
+ smith.idSeq++
+ return fmt.Sprintf("%v%v", prefix, smith.idSeq)
+}
+
+func (smith *Smith) enterBlock(nonextendable bool) {
+ b := &Block{parent: smith.curBlock, extendable: !nonextendable}
+ b.isBreakable = smith.curBlock.isBreakable
+ b.isContinuable = smith.curBlock.isContinuable
+ smith.curBlock.sub = append(smith.curBlock.sub, b)
+ smith.curBlock = b
+ smith.curBlockPos = -1
+}
+
+func (smith *Smith) leaveBlock() {
+ for _, b := range smith.curBlock.sub {
+ for _, v := range b.vars {
+ if !v.used {
+ smith.line("_ = %v", v.id)
+ }
+ }
+ }
+
+ smith.curBlock = smith.curBlock.parent
+ smith.curBlockPos = len(smith.curBlock.sub) - 1
+}
projects / dotfiles / .git / blobdiff