+++ /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