--- /dev/null
+package main
+
+import (
+ "bytes"
+ "fmt"
+)
+
+func (smith *Smith) initExpressions() {
+ smith.expressions = []func(res *Type) string{
+ smith.exprLiteral,
+ smith.exprVar,
+ smith.exprFunc,
+ smith.exprSelectorField,
+ smith.exprRecv,
+ smith.exprArith,
+ smith.exprEqual,
+ smith.exprOrder,
+ smith.exprCall,
+ smith.exprCallBuiltin,
+ smith.exprAddress,
+ smith.exprDeref,
+ smith.exprSlice,
+ smith.exprIndexSlice,
+ smith.exprIndexArray,
+ smith.exprIndexString,
+ smith.exprIndexMap,
+ smith.exprConversion,
+ }
+}
+
+func (smith *Smith) expression(res *Type) string {
+ smith.exprCount++
+ smith.totalExprCount++
+ if smith.exprDepth >= NExprDepth || smith.exprCount >= NExprCount || smith.totalExprCount >= NTotalExprCount {
+ return res.literal()
+ }
+ for {
+ smith.exprDepth++
+ s := smith.expressions[smith.rnd(len(smith.expressions))](res)
+ smith.exprDepth--
+ if s != "" {
+ return s
+ }
+ }
+}
+
+func (smith *Smith) rvalue(t *Type) string {
+ return smith.expression(t)
+}
+
+// rvalue, but not a const
+// used to index arrays and strings
+func (smith *Smith) nonconstRvalue(t *Type) string {
+ if t.class != ClassNumeric {
+ panic("bad")
+ }
+trying:
+ for {
+ res := ""
+ switch smith.choice("lvalue", "call", "len", "selector", "recv", "arith", "indexMap", "conv") {
+ case "lvalue":
+ res = smith.lvalue(t)
+ case "call":
+ res = smith.exprCall(t)
+ case "len":
+ tt := smith.atype(TraitLenCapable)
+ fn := smith.choice("len", "cap")
+ if (tt.class == ClassString || tt.class == ClassMap) && fn == "cap" {
+ break
+ }
+ if tt.class == ClassArray {
+ // len/cap are const
+ break
+ }
+ res = F("(%v)((%v)(%v))", t.id, fn, smith.lvalue(tt))
+ case "selector":
+ res = smith.exprSelectorField(t)
+ case "recv":
+ res = smith.exprRecv(t)
+ case "arith":
+ res = F("(%v) %v (%v)", smith.lvalue(t), smith.choice("+", "-"), smith.rvalue(t))
+ case "indexMap":
+ res = smith.exprIndexMap(t)
+ case "conv":
+ res = F("(%v)(%v %v)", t.id, smith.lvalue(smith.atype(ClassNumeric)), smith.choice("", ","))
+ default:
+ panic("bad")
+ }
+ if res == "" {
+ continue trying
+ }
+ return res
+ }
+}
+
+func (smith *Smith) lvalue(t *Type) string {
+ for {
+ switch smith.choice("var", "indexSlice", "indexArray", "selector", "deref") {
+ case "var":
+ return smith.exprVar(t)
+ case "indexSlice":
+ return smith.exprIndexSlice(t)
+ case "indexArray":
+ return F("(%v)[%v]", smith.lvalue(smith.arrayOf(t)), smith.nonconstRvalue(smith.intType))
+ case "selector":
+ for i := 0; i < 10; i++ {
+ st := smith.atype(ClassStruct)
+ for _, e := range st.elems {
+ if e.typ == t {
+ return F("(%v).%v", smith.lvalue(st), e.id)
+ }
+ }
+ }
+ continue
+ case "deref":
+ return smith.exprDeref(t)
+ default:
+ panic("bad")
+ }
+ }
+}
+
+func (smith *Smith) lvalueOrBlank(t *Type) string {
+ for {
+ switch smith.choice("lvalue", "map", "blank") {
+ case "lvalue":
+ return smith.lvalue(t)
+ case "map":
+ if e := smith.exprIndexMap(t); e != "" {
+ return e
+ }
+ case "blank":
+ return "_"
+ default:
+ panic("bad")
+ }
+ }
+}
+
+func (smith *Smith) lvalueOrMapIndex(t *Type) string {
+ for {
+ switch smith.choice("lvalue", "map") {
+ case "lvalue":
+ return smith.lvalue(t)
+ case "map":
+ if e := smith.exprIndexMap(t); e != "" {
+ return e
+ }
+ default:
+ panic("bad")
+ }
+ }
+}
+
+func (smith *Smith) fmtRvalueList(list []*Type) string {
+ var buf bytes.Buffer
+ for i, t := range list {
+ if i != 0 {
+ buf.Write([]byte{','})
+ }
+ fmt.Fprintf(&buf, "%v", smith.rvalue(t))
+ }
+ return buf.String()
+}
+
+func (smith *Smith) fmtLvalueList(list []*Type) string {
+ var buf bytes.Buffer
+ for i, t := range list {
+ if i != 0 {
+ buf.Write([]byte{','})
+ }
+ buf.WriteString(smith.lvalueOrBlank(t))
+ }
+ return buf.String()
+}
+
+func (smith *Smith) fmtOasVarList(list []*Type) (str string, newVars []*Var) {
+ allVars := smith.vars()
+ var buf bytes.Buffer
+ for i, t := range list {
+ expr := "_"
+ // First, try to find an existing var in the same scope.
+ if smith.rndBool() {
+ for i, v := range allVars {
+ if v.typ == t && v.block == smith.curBlock {
+ allVars[i] = allVars[len(allVars)-1]
+ allVars = allVars[:len(allVars)-1]
+ expr = v.id
+ break
+ }
+ }
+ }
+ if smith.rndBool() || (i == len(list)-1 && len(newVars) == 0) {
+ expr = smith.newId("Var")
+ newVars = append(newVars, &Var{id: expr, typ: t})
+ }
+
+ if i != 0 {
+ buf.WriteString(", ")
+ }
+ buf.WriteString(expr)
+ }
+ return buf.String(), newVars
+}
+
+func (smith *Smith) exprLiteral(res *Type) string {
+ if res.complexLiteral != nil {
+ return res.complexLiteral()
+ }
+ return res.literal()
+}
+
+func (smith *Smith) exprVar(res *Type) string {
+ for _, v := range smith.vars() {
+ if v.typ == res {
+ return v.id
+ }
+ }
+ return smith.materializeVar(res)
+}
+
+func (smith *Smith) exprSelectorField(res *Type) string {
+ for i := 0; i < 10; i++ {
+ st := smith.atype(ClassStruct)
+ for _, e := range st.elems {
+ if e.typ == res {
+ return F("(%v).%v", smith.rvalue(st), e.id)
+ }
+ }
+ }
+ return ""
+}
+
+func (smith *Smith) exprFunc(res *Type) string {
+ if !smith.satisfiesTrait(res, TraitGlobal) {
+ return ""
+ }
+ var f *Func
+ for _, f1 := range smith.packages[smith.curPackage].toplevFuncs {
+ if len(f1.rets) == 1 && f1.rets[0] == res {
+ f = f1
+ break
+ }
+ }
+ if f == nil {
+ f = smith.materializeFunc([]*Type{res})
+ }
+ if smith.rndBool() {
+ return F("%v(%v)", f.name, smith.fmtRvalueList(f.args))
+ } else {
+ var f0 *Func
+ loop:
+ for _, f1 := range smith.packages[smith.curPackage].toplevFuncs {
+ if len(f1.rets) == len(f.args) {
+ for i := range f.args {
+ // TODO: check assignability
+ if f1.rets[i] != f.args[i] {
+ continue loop
+ }
+ }
+ f0 = f1
+ break
+ }
+ }
+ if f0 == nil {
+ f0 = smith.materializeFunc(f.args)
+ }
+ return F("%v(%v(%v))", f.name, f0.name, smith.fmtRvalueList(f0.args))
+ }
+}
+
+func (smith *Smith) exprAddress(res *Type) string {
+ if res.class != ClassPointer {
+ return ""
+ }
+ if res.ktyp.class == ClassStruct && smith.rndBool() {
+ return F("&%v", res.ktyp.complexLiteral())
+ }
+ return F("(%v)(&(%v))", res.id, smith.lvalue(res.ktyp))
+}
+
+func (smith *Smith) exprDeref(res *Type) string {
+ return F("(*(%v))", smith.lvalue(pointerTo(res)))
+}
+
+func (smith *Smith) exprRecv(res *Type) string {
+ t := smith.chanOf(res)
+ return F("(<- %v)", smith.rvalue(t))
+}
+
+func (smith *Smith) exprArith(res *Type) string {
+ if res.class != ClassNumeric && res.class != ClassComplex {
+ return ""
+ }
+ // "/" causes division by zero
+ // "*" causes generation of -1 index in int(real(1i * 1i))
+ return F("(%v) + (%v)", smith.rvalue(res), smith.rvalue(res))
+}
+
+func (smith *Smith) exprEqual(res *Type) string {
+ if res != smith.boolType {
+ return ""
+ }
+ t := smith.atype(TraitComparable)
+ return F("(%v) %v (%v)", smith.rvalue(t), smith.choice("==", "!="), smith.rvalue(t))
+}
+
+func (smith *Smith) exprOrder(res *Type) string {
+ if res != smith.boolType {
+ return ""
+ }
+ t := smith.atype(TraitOrdered)
+ return F("(%v) %v (%v)", smith.rvalue(t), smith.choice("<", "<=", ">", ">="), smith.rvalue(t))
+
+}
+
+func (smith *Smith) exprCall(ret *Type) string {
+ t := smith.funcOf(smith.atypeList(TraitAny), []*Type{ret})
+ return F("%v(%v)", smith.rvalue(t), smith.fmtRvalueList(t.styp))
+}
+
+func (smith *Smith) exprCallBuiltin(ret *Type) string {
+ switch fn := smith.choice("append", "cap", "complex", "copy", "imag", "len", "make", "new", "real", "recover"); fn {
+ case "append":
+ if ret.class != ClassSlice {
+ return ""
+ }
+ switch smith.choice("one", "two", "slice") {
+ case "one":
+ return F("%v(%v, %v)", fn, smith.rvalue(ret), smith.rvalue(ret.ktyp))
+ case "two":
+ return F("%v(%v, %v, %v)", fn, smith.rvalue(ret), smith.rvalue(ret.ktyp), smith.rvalue(ret.ktyp))
+ case "slice":
+ return F("%v(%v, %v...)", fn, smith.rvalue(ret), smith.rvalue(ret))
+ default:
+ panic("bad")
+ }
+ case "len", "cap":
+ if ret != smith.intType { // TODO: must be convertable
+ return ""
+ }
+ t := smith.atype(TraitLenCapable)
+ if (t.class == ClassString || t.class == ClassMap) && fn == "cap" {
+ return ""
+
+ }
+ return F("%v(%v)", fn, smith.rvalue(t))
+ case "copy":
+ if ret != smith.intType {
+ return ""
+ }
+ return F("%v", smith.exprCopySlice())
+ case "make":
+ if ret.class != ClassSlice && ret.class != ClassMap && ret.class != ClassChan {
+ return ""
+ }
+ cap := ""
+ if ret.class == ClassSlice {
+ if smith.rndBool() {
+ cap = F(", %v", smith.rvalue(smith.intType))
+ } else {
+ // Careful to not generate "len larger than cap".
+ cap = F(", 0, %v", smith.rvalue(smith.intType))
+ }
+ } else if smith.rndBool() {
+ cap = F(", %v", smith.rvalue(smith.intType))
+ }
+ return F("make(%v %v)", ret.id, cap)
+ case "new":
+ if ret.class != ClassPointer {
+ return ""
+ }
+ return F("new(%v)", ret.ktyp.id)
+ case "recover":
+ if ret != smith.efaceType {
+ return ""
+ }
+ return "recover()"
+ case "real", "imag":
+ if ret == smith.float32Type {
+ return F("real(%v)", smith.rvalue(smith.complex64Type))
+ }
+ if ret == smith.float64Type {
+ return F("real(%v)", smith.rvalue(smith.complex128Type))
+ }
+ return ""
+ case "complex":
+ if ret == smith.complex64Type {
+ return F("complex(%v, %v)", smith.rvalue(smith.float32Type), smith.rvalue(smith.float32Type))
+ }
+ if ret == smith.complex128Type {
+ return F("complex(%v, %v)", smith.rvalue(smith.float64Type), smith.rvalue(smith.float64Type))
+ }
+ return ""
+ default:
+ panic("bad")
+ }
+}
+
+func (smith *Smith) exprCopySlice() string {
+ if smith.rndBool() {
+ t := smith.atype(ClassSlice)
+ return F("copy(%v, %v)", smith.rvalue(t), smith.rvalue(t))
+ } else {
+ return F("copy(%v, %v)", smith.rvalue(smith.sliceOf(smith.byteType)), smith.rvalue(smith.stringType))
+ }
+}
+
+func (smith *Smith) exprSlice(ret *Type) string {
+ if ret.class != ClassSlice {
+ return ""
+ }
+ i0 := ""
+ if smith.rndBool() {
+ i0 = smith.nonconstRvalue(smith.intType)
+ }
+ i2 := ""
+ if smith.rndBool() {
+ i2 = ":" + smith.nonconstRvalue(smith.intType)
+ }
+ i1 := ":"
+ if smith.rndBool() || i2 != "" {
+ i1 = ":" + smith.nonconstRvalue(smith.intType)
+ }
+ return F("(%v)[%v%v%v]", smith.rvalue(ret), i0, i1, i2)
+}
+
+func (smith *Smith) exprIndexSlice(ret *Type) string {
+ return F("(%v)[%v]", smith.rvalue(smith.sliceOf(ret)), smith.nonconstRvalue(smith.intType))
+}
+
+func (smith *Smith) exprIndexString(ret *Type) string {
+ if ret != smith.byteType {
+ return ""
+ }
+ return F("(%v)[%v]", smith.rvalue(smith.stringType), smith.nonconstRvalue(smith.intType))
+}
+
+func (smith *Smith) exprIndexArray(ret *Type) string {
+ // TODO: also handle indexing of pointers to arrays
+ return F("(%v)[%v]", smith.rvalue(smith.arrayOf(ret)), smith.nonconstRvalue(smith.intType))
+}
+
+func (smith *Smith) exprIndexMap(ret *Type) string {
+ // TODO: figure out something better
+ for i := 0; i < 10; i++ {
+ t := smith.atype(ClassMap)
+ if t.vtyp == ret {
+ return F("(%v)[%v]", smith.rvalue(t), smith.rvalue(t.ktyp))
+ }
+ }
+ return ""
+}
+
+func (smith *Smith) exprConversion(ret *Type) string {
+ if ret.class == ClassNumeric {
+ return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.atype(ClassNumeric)), smith.choice("", ","))
+ }
+ if ret.class == ClassComplex {
+ return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.atype(ClassComplex)), smith.choice("", ","))
+ }
+ if ret == smith.stringType {
+ switch smith.choice("int", "byteSlice", "runeSlice") {
+ case "int":
+ // We produce a string of length at least 3, to not produce
+ // "invalid string index 1 (out of bounds for 1-byte string)"
+ return F("(%v)((%v) + (1<<24) %v)", ret.id, smith.rvalue(smith.intType), smith.choice("", ","))
+ case "byteSlice":
+ return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.sliceOf(smith.byteType)), smith.choice("", ","))
+ case "runeSlice":
+ return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.sliceOf(smith.runeType)), smith.choice("", ","))
+ default:
+ panic("bad")
+ }
+ }
+ if ret.class == ClassSlice && (ret.ktyp == smith.byteType || ret.ktyp == smith.runeType) {
+ return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.stringType), smith.choice("", ","))
+ }
+ // TODO: handle "x is assignable to T"
+ // TODO: handle "x's type and T have identical underlying types"
+ // TODO: handle "x's type and T are unnamed pointer types and their pointer base types have identical underlying types"
+ return ""
+}
projects / dotfiles / .git / blobdiff