func (f *Finder) builtin(obj *types.Builtin, sig *types.Signature, args []ast.Expr, T types.Type) types.Type {
switch obj.Name() {
case "make", "new":
// skip the type operand
for _, arg := range args[1:] {
f.expr(arg)
}
case "append":
s := f.expr(args[0])
if _, ok := args[len(args)-1].(*ast.Ellipsis); ok && len(args) == 2 {
// append(x, y...) including append([]byte, "foo"...)
f.expr(args[1])
} else {
// append(x, y, z)
tElem := s.Underlying().(*types.Slice).Elem()
for _, arg := range args[1:] {
f.assign(tElem, f.expr(arg))
}
}
case "delete":
m := f.expr(args[0])
k := f.expr(args[1])
f.assign(m.Underlying().(*types.Map).Key(), k)
default:
// ordinary call
f.call(sig, args)
}
return T
}
func (c *funcContext) translateStmt(stmt ast.Stmt, label *types.Label) {
c.SetPos(stmt.Pos())
stmt = filter.IncDecStmt(stmt, c.p.Info)
stmt = filter.Assign(stmt, c.p.Info)
switch s := stmt.(type) {
case *ast.BlockStmt:
c.translateStmtList(s.List)
case *ast.IfStmt:
if s.Init != nil {
c.translateStmt(s.Init, nil)
}
var caseClauses []ast.Stmt
ifStmt := s
for {
caseClauses = append(caseClauses, &ast.CaseClause{List: []ast.Expr{ifStmt.Cond}, Body: ifStmt.Body.List})
switch elseStmt := ifStmt.Else.(type) {
case *ast.IfStmt:
if elseStmt.Init != nil {
caseClauses = append(caseClauses, &ast.CaseClause{List: nil, Body: []ast.Stmt{elseStmt}})
break
}
ifStmt = elseStmt
continue
case *ast.BlockStmt:
caseClauses = append(caseClauses, &ast.CaseClause{List: nil, Body: elseStmt.List})
case *ast.EmptyStmt, nil:
// no else clause
default:
panic(fmt.Sprintf("Unhandled else: %T\n", elseStmt))
}
break
}
c.translateBranchingStmt(caseClauses, false, nil, nil, nil, c.Flattened[s])
case *ast.SwitchStmt:
if s.Init != nil {
c.translateStmt(s.Init, nil)
}
tag := s.Tag
if tag == nil {
tag = ast.NewIdent("true")
c.p.Types[tag] = types.TypeAndValue{Type: types.Typ[types.Bool], Value: exact.MakeBool(true)}
}
if c.p.Types[tag].Value == nil {
refVar := c.newVariable("_ref")
c.Printf("%s = %s;", refVar, c.translateExpr(tag))
tag = c.newIdent(refVar, c.p.Types[tag].Type)
}
translateCond := func(cond ast.Expr) *expression {
return c.translateExpr(&ast.BinaryExpr{
X: tag,
Op: token.EQL,
Y: cond,
})
}
c.translateBranchingStmt(s.Body.List, true, translateCond, nil, label, c.Flattened[s])
case *ast.TypeSwitchStmt:
if s.Init != nil {
c.translateStmt(s.Init, nil)
}
refVar := c.newVariable("_ref")
var expr ast.Expr
var printCaseBodyPrefix func(index int)
switch a := s.Assign.(type) {
case *ast.AssignStmt:
expr = a.Rhs[0].(*ast.TypeAssertExpr).X
printCaseBodyPrefix = func(index int) {
value := refVar
caseClause := s.Body.List[index].(*ast.CaseClause)
if len(caseClause.List) == 1 {
t := c.p.Types[caseClause.List[0]].Type
if _, isInterface := t.Underlying().(*types.Interface); !isInterface && !types.Identical(t, types.Typ[types.UntypedNil]) {
value += ".$val"
}
}
c.Printf("%s = %s;", c.objectName(c.p.Implicits[caseClause]), value)
}
case *ast.ExprStmt:
expr = a.X.(*ast.TypeAssertExpr).X
}
c.Printf("%s = %s;", refVar, c.translateExpr(expr))
translateCond := func(cond ast.Expr) *expression {
if types.Identical(c.p.Types[cond].Type, types.Typ[types.UntypedNil]) {
return c.formatExpr("%s === $ifaceNil", refVar)
}
return c.formatExpr("$assertType(%s, %s, true)[1]", refVar, c.typeName(c.p.Types[cond].Type))
}
c.translateBranchingStmt(s.Body.List, true, translateCond, printCaseBodyPrefix, label, c.Flattened[s])
case *ast.ForStmt:
if s.Init != nil {
c.translateStmt(s.Init, nil)
}
cond := func() string {
if s.Cond == nil {
return "true"
}
return c.translateExpr(s.Cond).String()
}
c.translateLoopingStmt(cond, s.Body, nil, func() {
if s.Post != nil {
c.translateStmt(s.Post, nil)
}
}, label, c.Flattened[s])
case *ast.RangeStmt:
refVar := c.newVariable("_ref")
c.Printf("%s = %s;", refVar, c.translateExpr(s.X))
switch t := c.p.Types[s.X].Type.Underlying().(type) {
case *types.Basic:
iVar := c.newVariable("_i")
c.Printf("%s = 0;", iVar)
runeVar := c.newVariable("_rune")
c.translateLoopingStmt(func() string { return iVar + " < " + refVar + ".length" }, s.Body, func() {
c.Printf("%s = $decodeRune(%s, %s);", runeVar, refVar, iVar)
if !isBlank(s.Key) {
c.Printf("%s", c.translateAssign(s.Key, iVar, types.Typ[types.Int], s.Tok == token.DEFINE))
}
if !isBlank(s.Value) {
c.Printf("%s", c.translateAssign(s.Value, runeVar+"[0]", types.Typ[types.Rune], s.Tok == token.DEFINE))
}
}, func() {
c.Printf("%s += %s[1];", iVar, runeVar)
}, label, c.Flattened[s])
case *types.Map:
iVar := c.newVariable("_i")
c.Printf("%s = 0;", iVar)
keysVar := c.newVariable("_keys")
c.Printf("%s = $keys(%s);", keysVar, refVar)
c.translateLoopingStmt(func() string { return iVar + " < " + keysVar + ".length" }, s.Body, func() {
entryVar := c.newVariable("_entry")
c.Printf("%s = %s[%s[%s]];", entryVar, refVar, keysVar, iVar)
c.translateStmt(&ast.IfStmt{
Cond: c.newIdent(entryVar+" === undefined", types.Typ[types.Bool]),
Body: &ast.BlockStmt{List: []ast.Stmt{&ast.BranchStmt{Tok: token.CONTINUE}}},
}, nil)
if !isBlank(s.Key) {
c.Printf("%s", c.translateAssign(s.Key, entryVar+".k", t.Key(), s.Tok == token.DEFINE))
}
if !isBlank(s.Value) {
c.Printf("%s", c.translateAssign(s.Value, entryVar+".v", t.Elem(), s.Tok == token.DEFINE))
}
}, func() {
c.Printf("%s++;", iVar)
}, label, c.Flattened[s])
case *types.Array, *types.Pointer, *types.Slice:
var length string
var elemType types.Type
switch t2 := t.(type) {
case *types.Array:
length = fmt.Sprintf("%d", t2.Len())
elemType = t2.Elem()
case *types.Pointer:
length = fmt.Sprintf("%d", t2.Elem().Underlying().(*types.Array).Len())
elemType = t2.Elem().Underlying().(*types.Array).Elem()
case *types.Slice:
length = refVar + ".$length"
elemType = t2.Elem()
}
iVar := c.newVariable("_i")
c.Printf("%s = 0;", iVar)
c.translateLoopingStmt(func() string { return iVar + " < " + length }, s.Body, func() {
if !isBlank(s.Key) {
c.Printf("%s", c.translateAssign(s.Key, iVar, types.Typ[types.Int], s.Tok == token.DEFINE))
}
if !isBlank(s.Value) {
c.Printf("%s", c.translateAssign(s.Value, c.translateImplicitConversion(c.setType(&ast.IndexExpr{
X: c.newIdent(refVar, t),
Index: c.newIdent(iVar, types.Typ[types.Int]),
}, elemType), elemType).String(), elemType, s.Tok == token.DEFINE))
}
}, func() {
c.Printf("%s++;", iVar)
}, label, c.Flattened[s])
case *types.Chan:
okVar := c.newIdent(c.newVariable("_ok"), types.Typ[types.Bool])
key := s.Key
tok := s.Tok
if key == nil {
key = ast.NewIdent("_")
tok = token.ASSIGN
}
forStmt := &ast.ForStmt{
Body: &ast.BlockStmt{
List: []ast.Stmt{
&ast.AssignStmt{
Lhs: []ast.Expr{
key,
okVar,
},
Rhs: []ast.Expr{
c.setType(&ast.UnaryExpr{X: c.newIdent(refVar, t), Op: token.ARROW}, types.NewTuple(types.NewVar(0, nil, "", t.Elem()), types.NewVar(0, nil, "", types.Typ[types.Bool]))),
},
Tok: tok,
},
&ast.IfStmt{
Cond: &ast.UnaryExpr{X: okVar, Op: token.NOT},
Body: &ast.BlockStmt{List: []ast.Stmt{&ast.BranchStmt{Tok: token.BREAK}}},
},
s.Body,
},
},
}
c.Flattened[forStmt] = true
c.translateStmt(forStmt, label)
default:
panic("")
}
case *ast.BranchStmt:
normalLabel := ""
blockingLabel := ""
data := c.flowDatas[nil]
if s.Label != nil {
normalLabel = " " + s.Label.Name
blockingLabel = " s" // use explicit label "s", because surrounding loop may not be flattened
data = c.flowDatas[c.p.Uses[s.Label].(*types.Label)]
}
switch s.Tok {
case token.BREAK:
c.PrintCond(data.endCase == 0, fmt.Sprintf("break%s;", normalLabel), fmt.Sprintf("$s = %d; continue%s;", data.endCase, blockingLabel))
case token.CONTINUE:
data.postStmt()
c.PrintCond(data.beginCase == 0, fmt.Sprintf("continue%s;", normalLabel), fmt.Sprintf("$s = %d; continue%s;", data.beginCase, blockingLabel))
case token.GOTO:
c.PrintCond(false, "goto "+s.Label.Name, fmt.Sprintf("$s = %d; continue;", c.labelCase(c.p.Uses[s.Label].(*types.Label))))
case token.FALLTHROUGH:
// handled in CaseClause
default:
panic("Unhandled branch statment: " + s.Tok.String())
}
case *ast.ReturnStmt:
results := s.Results
if c.resultNames != nil {
if len(s.Results) != 0 {
c.translateStmt(&ast.AssignStmt{
Lhs: c.resultNames,
Tok: token.ASSIGN,
Rhs: s.Results,
}, nil)
}
results = c.resultNames
}
c.Printf("return%s;", c.translateResults(results))
case *ast.DeferStmt:
isBuiltin := false
isJs := false
switch fun := s.Call.Fun.(type) {
case *ast.Ident:
var builtin *types.Builtin
builtin, isBuiltin = c.p.Uses[fun].(*types.Builtin)
if isBuiltin && builtin.Name() == "recover" {
c.Printf("$deferred.push([$recover, []]);")
return
}
case *ast.SelectorExpr:
isJs = typesutil.IsJsPackage(c.p.Uses[fun.Sel].Pkg())
}
sig := c.p.Types[s.Call.Fun].Type.Underlying().(*types.Signature)
args := c.translateArgs(sig, s.Call.Args, s.Call.Ellipsis.IsValid(), true)
if isBuiltin || isJs {
vars := make([]string, len(s.Call.Args))
callArgs := make([]ast.Expr, len(s.Call.Args))
for i, arg := range s.Call.Args {
v := c.newVariable("_arg")
vars[i] = v
callArgs[i] = c.newIdent(v, c.p.Types[arg].Type)
}
call := c.translateExpr(&ast.CallExpr{
Fun: s.Call.Fun,
Args: callArgs,
Ellipsis: s.Call.Ellipsis,
})
c.Printf("$deferred.push([function(%s) { %s; }, [%s]]);", strings.Join(vars, ", "), call, strings.Join(args, ", "))
return
}
c.Printf("$deferred.push([%s, [%s]]);", c.translateExpr(s.Call.Fun), strings.Join(args, ", "))
case *ast.AssignStmt:
if s.Tok != token.ASSIGN && s.Tok != token.DEFINE {
panic(s.Tok)
}
if s.Tok == token.DEFINE {
for _, lhs := range s.Lhs {
if !isBlank(lhs) {
obj := c.p.Defs[lhs.(*ast.Ident)]
if obj == nil {
obj = c.p.Uses[lhs.(*ast.Ident)]
}
c.setType(lhs, obj.Type())
}
}
}
switch {
case len(s.Lhs) == 1 && len(s.Rhs) == 1:
lhs := astutil.RemoveParens(s.Lhs[0])
if isBlank(lhs) {
if analysis.HasSideEffect(s.Rhs[0], c.p.Info.Info) {
c.Printf("%s;", c.translateExpr(s.Rhs[0]).String())
}
return
}
lhsType := c.p.Types[s.Lhs[0]].Type
c.Printf("%s", c.translateAssignOfExpr(lhs, s.Rhs[0], lhsType, s.Tok == token.DEFINE))
case len(s.Lhs) > 1 && len(s.Rhs) == 1:
tupleVar := c.newVariable("_tuple")
out := tupleVar + " = " + c.translateExpr(s.Rhs[0]).String() + ";"
tuple := c.p.Types[s.Rhs[0]].Type.(*types.Tuple)
for i, lhs := range s.Lhs {
lhs = astutil.RemoveParens(lhs)
if !isBlank(lhs) {
lhsType := c.p.Types[s.Lhs[i]].Type
out += " " + c.translateAssignOfExpr(lhs, c.newIdent(fmt.Sprintf("%s[%d]", tupleVar, i), tuple.At(i).Type()), lhsType, s.Tok == token.DEFINE)
}
}
c.Printf("%s", out)
case len(s.Lhs) == len(s.Rhs):
tmpVars := make([]string, len(s.Rhs))
var parts []string
for i, rhs := range s.Rhs {
tmpVars[i] = c.newVariable("_tmp")
if isBlank(astutil.RemoveParens(s.Lhs[i])) {
if analysis.HasSideEffect(rhs, c.p.Info.Info) {
c.Printf("%s;", c.translateExpr(rhs).String())
}
continue
}
lhsType := c.p.Types[s.Lhs[i]].Type
parts = append(parts, c.translateAssignOfExpr(c.newIdent(tmpVars[i], c.p.Types[s.Lhs[i]].Type), rhs, lhsType, true))
}
for i, lhs := range s.Lhs {
lhs = astutil.RemoveParens(lhs)
if !isBlank(lhs) {
t := c.p.Types[lhs].Type
parts = append(parts, c.translateAssignOfExpr(lhs, c.newIdent(tmpVars[i], t), t, s.Tok == token.DEFINE))
}
}
c.Printf("%s", strings.Join(parts, " "))
default:
panic("Invalid arity of AssignStmt.")
}
case *ast.DeclStmt:
decl := s.Decl.(*ast.GenDecl)
switch decl.Tok {
case token.VAR:
for _, spec := range s.Decl.(*ast.GenDecl).Specs {
valueSpec := spec.(*ast.ValueSpec)
lhs := make([]ast.Expr, len(valueSpec.Names))
for i, name := range valueSpec.Names {
lhs[i] = name
}
rhs := valueSpec.Values
isTuple := false
if len(rhs) == 1 {
_, isTuple = c.p.Types[rhs[0]].Type.(*types.Tuple)
}
for len(rhs) < len(lhs) && !isTuple {
rhs = append(rhs, nil)
}
c.translateStmt(&ast.AssignStmt{
Lhs: lhs,
Tok: token.DEFINE,
Rhs: rhs,
}, nil)
}
case token.TYPE:
for _, spec := range decl.Specs {
o := c.p.Defs[spec.(*ast.TypeSpec).Name].(*types.TypeName)
c.p.typeNames = append(c.p.typeNames, o)
c.p.objectNames[o] = c.newVariableWithLevel(o.Name(), true)
c.p.dependencies[o] = true
}
case token.CONST:
// skip, constants are inlined
}
case *ast.ExprStmt:
expr := c.translateExpr(s.X)
if expr != nil && expr.String() != "" {
c.Printf("%s;", expr)
}
case *ast.LabeledStmt:
label := c.p.Defs[s.Label].(*types.Label)
if c.GotoLabel[label] {
c.PrintCond(false, s.Label.Name+":", fmt.Sprintf("case %d:", c.labelCase(label)))
}
c.translateStmt(s.Stmt, label)
case *ast.GoStmt:
c.Printf("$go(%s, [%s]);", c.translateExpr(s.Call.Fun), strings.Join(c.translateArgs(c.p.Types[s.Call.Fun].Type.Underlying().(*types.Signature), s.Call.Args, s.Call.Ellipsis.IsValid(), false), ", "))
case *ast.SendStmt:
chanType := c.p.Types[s.Chan].Type.Underlying().(*types.Chan)
call := &ast.CallExpr{
Fun: c.newIdent("$send", types.NewSignature(nil, types.NewTuple(types.NewVar(0, nil, "", chanType), types.NewVar(0, nil, "", chanType.Elem())), nil, false)),
Args: []ast.Expr{s.Chan, s.Value},
}
c.Blocking[call] = true
c.translateStmt(&ast.ExprStmt{X: call}, label)
case *ast.SelectStmt:
var channels []string
var caseClauses []ast.Stmt
flattened := false
hasDefault := false
for i, s := range s.Body.List {
clause := s.(*ast.CommClause)
switch comm := clause.Comm.(type) {
case nil:
channels = append(channels, "[]")
hasDefault = true
case *ast.ExprStmt:
channels = append(channels, c.formatExpr("[%e]", astutil.RemoveParens(comm.X).(*ast.UnaryExpr).X).String())
case *ast.AssignStmt:
channels = append(channels, c.formatExpr("[%e]", astutil.RemoveParens(comm.Rhs[0]).(*ast.UnaryExpr).X).String())
case *ast.SendStmt:
channels = append(channels, c.formatExpr("[%e, %e]", comm.Chan, comm.Value).String())
default:
panic(fmt.Sprintf("unhandled: %T", comm))
}
indexLit := &ast.BasicLit{Kind: token.INT}
c.p.Types[indexLit] = types.TypeAndValue{Type: types.Typ[types.Int], Value: exact.MakeInt64(int64(i))}
caseClauses = append(caseClauses, &ast.CaseClause{
List: []ast.Expr{indexLit},
Body: clause.Body,
})
flattened = flattened || c.Flattened[clause]
}
selectCall := c.setType(&ast.CallExpr{
Fun: c.newIdent("$select", types.NewSignature(nil, types.NewTuple(types.NewVar(0, nil, "", types.NewInterface(nil, nil))), types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int])), false)),
Args: []ast.Expr{c.newIdent(fmt.Sprintf("[%s]", strings.Join(channels, ", ")), types.NewInterface(nil, nil))},
}, types.Typ[types.Int])
c.Blocking[selectCall] = !hasDefault
selectionVar := c.newVariable("_selection")
c.Printf("%s = %s;", selectionVar, c.translateExpr(selectCall))
translateCond := func(cond ast.Expr) *expression {
return c.formatExpr("%s[0] === %e", selectionVar, cond)
}
printCaseBodyPrefix := func(index int) {
if assign, ok := s.Body.List[index].(*ast.CommClause).Comm.(*ast.AssignStmt); ok {
switch rhsType := c.p.Types[assign.Rhs[0]].Type.(type) {
case *types.Tuple:
c.translateStmt(&ast.AssignStmt{Lhs: assign.Lhs, Rhs: []ast.Expr{c.newIdent(selectionVar+"[1]", rhsType)}, Tok: assign.Tok}, nil)
default:
c.translateStmt(&ast.AssignStmt{Lhs: assign.Lhs, Rhs: []ast.Expr{c.newIdent(selectionVar+"[1][0]", rhsType)}, Tok: assign.Tok}, nil)
}
}
}
c.translateBranchingStmt(caseClauses, true, translateCond, printCaseBodyPrefix, label, flattened)
case *ast.EmptyStmt:
// skip
default:
panic(fmt.Sprintf("Unhandled statement: %T\n", s))
}
}