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 string) {
c.WritePos(stmt.Pos())
switch s := stmt.(type) {
case *ast.BlockStmt:
c.printLabel(label)
c.translateStmtList(s.List)
case *ast.IfStmt:
c.printLabel(label)
if s.Init != nil {
c.translateStmt(s.Init, "")
}
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, c.translateExpr, nil, "", c.flattened[s])
case *ast.SwitchStmt:
if s.Init != nil {
c.translateStmt(s.Init, "")
}
translateCond := func(cond ast.Expr) *expression {
return c.translateExpr(cond)
}
if s.Tag != nil {
refVar := c.newVariable("_ref")
c.Printf("%s = %s;", refVar, c.translateExpr(s.Tag))
translateCond = func(cond ast.Expr) *expression {
return c.translateExpr(&ast.BinaryExpr{
X: c.newIdent(refVar, c.p.info.Types[s.Tag].Type),
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, "")
}
var expr ast.Expr
var typeSwitchVar string
switch a := s.Assign.(type) {
case *ast.AssignStmt:
expr = a.Rhs[0].(*ast.TypeAssertExpr).X
typeSwitchVar = c.newVariable(a.Lhs[0].(*ast.Ident).Name)
for _, caseClause := range s.Body.List {
c.p.objectVars[c.p.info.Implicits[caseClause]] = typeSwitchVar
}
case *ast.ExprStmt:
expr = a.X.(*ast.TypeAssertExpr).X
}
refVar := c.newVariable("_ref")
c.Printf("%s = %s;", refVar, c.translateExpr(expr))
translateCond := func(cond ast.Expr) *expression {
if types.Identical(c.p.info.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.info.Types[cond].Type))
}
printCaseBodyPrefix := func(index int) {
if typeSwitchVar == "" {
return
}
value := refVar
if conds := s.Body.List[index].(*ast.CaseClause).List; len(conds) == 1 {
t := c.p.info.Types[conds[0]].Type
if _, isInterface := t.Underlying().(*types.Interface); !isInterface && !types.Identical(t, types.Typ[types.UntypedNil]) {
value += ".$val"
}
}
c.Printf("%s = %s;", typeSwitchVar, value)
}
c.translateBranchingStmt(s.Body.List, true, translateCond, printCaseBodyPrefix, label, c.flattened[s])
case *ast.ForStmt:
if s.Init != nil {
c.translateStmt(s.Init, "")
}
cond := "true"
if s.Cond != nil {
cond = c.translateExpr(s.Cond).String()
}
c.translateLoopingStmt(cond, s.Body, nil, func() {
if s.Post != nil {
c.translateStmt(s.Post, "")
}
}, label, c.flattened[s])
case *ast.RangeStmt:
refVar := c.newVariable("_ref")
c.Printf("%s = %s;", refVar, c.translateExpr(s.X))
switch t := c.p.info.Types[s.X].Type.Underlying().(type) {
case *types.Basic:
iVar := c.newVariable("_i")
c.Printf("%s = 0;", iVar)
runeVar := c.newVariable("_rune")
c.translateLoopingStmt(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(iVar+" < "+keysVar+".length", s.Body, func() {
entryVar := c.newVariable("_entry")
c.Printf("%s = %s[%s[%s]];", entryVar, refVar, keysVar, iVar)
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(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])
forStmt := &ast.ForStmt{
Body: &ast.BlockStmt{
List: []ast.Stmt{
&ast.AssignStmt{
Lhs: []ast.Expr{
s.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: s.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:
c.printLabel(label)
labelSuffix := ""
data := c.flowDatas[""]
if s.Label != nil {
labelSuffix = " " + s.Label.Name
data = c.flowDatas[s.Label.Name]
}
switch s.Tok {
case token.BREAK:
c.PrintCond(data.endCase == 0, fmt.Sprintf("break%s;", labelSuffix), fmt.Sprintf("$s = %d; continue;", data.endCase))
case token.CONTINUE:
data.postStmt()
c.PrintCond(data.beginCase == 0, fmt.Sprintf("continue%s;", labelSuffix), fmt.Sprintf("$s = %d; continue;", data.beginCase))
case token.GOTO:
c.PrintCond(false, "goto "+s.Label.Name, fmt.Sprintf("$s = %d; continue;", c.labelCases[s.Label.Name]))
case token.FALLTHROUGH:
// handled in CaseClause
default:
panic("Unhandled branch statment: " + s.Tok.String())
}
case *ast.ReturnStmt:
c.printLabel(label)
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,
}, "")
}
results = c.resultNames
}
switch len(results) {
case 0:
c.Printf("return;")
case 1:
if c.sig.Results().Len() > 1 {
c.Printf("return %s;", c.translateExpr(results[0]))
return
}
v := c.translateImplicitConversion(results[0], c.sig.Results().At(0).Type())
c.delayedOutput = nil
c.Printf("return %s;", v)
default:
values := make([]string, len(results))
for i, result := range results {
values[i] = c.translateImplicitConversion(result, c.sig.Results().At(i).Type()).String()
}
c.delayedOutput = nil
c.Printf("return [%s];", strings.Join(values, ", "))
}
case *ast.DeferStmt:
c.printLabel(label)
isBuiltin := false
isJs := false
switch fun := s.Call.Fun.(type) {
case *ast.Ident:
var builtin *types.Builtin
builtin, isBuiltin = c.p.info.Uses[fun].(*types.Builtin)
if isBuiltin && builtin.Name() == "recover" {
c.Printf("$deferred.push([$recover, []]);")
return
}
case *ast.SelectorExpr:
isJs = isJsPackage(c.p.info.Uses[fun.Sel].Pkg())
}
if isBuiltin || isJs {
args := make([]ast.Expr, len(s.Call.Args))
for i, arg := range s.Call.Args {
args[i] = c.newIdent(c.newVariable("_arg"), c.p.info.Types[arg].Type)
}
call := c.translateExpr(&ast.CallExpr{
Fun: s.Call.Fun,
Args: args,
Ellipsis: s.Call.Ellipsis,
})
c.Printf("$deferred.push([function(%s) { %s; }, [%s]]);", strings.Join(c.translateExprSlice(args, nil), ", "), call, strings.Join(c.translateExprSlice(s.Call.Args, nil), ", "))
return
}
sig := c.p.info.Types[s.Call.Fun].Type.Underlying().(*types.Signature)
args := c.translateArgs(sig, s.Call.Args, s.Call.Ellipsis.IsValid())
if len(c.blocking) != 0 {
args = append(args, "true")
}
c.Printf("$deferred.push([%s, [%s]]);", c.translateExpr(s.Call.Fun), strings.Join(args, ", "))
case *ast.AssignStmt:
c.printLabel(label)
if s.Tok != token.ASSIGN && s.Tok != token.DEFINE {
var op token.Token
switch s.Tok {
case token.ADD_ASSIGN:
op = token.ADD
case token.SUB_ASSIGN:
op = token.SUB
case token.MUL_ASSIGN:
op = token.MUL
case token.QUO_ASSIGN:
op = token.QUO
case token.REM_ASSIGN:
op = token.REM
case token.AND_ASSIGN:
op = token.AND
case token.OR_ASSIGN:
op = token.OR
case token.XOR_ASSIGN:
op = token.XOR
case token.SHL_ASSIGN:
op = token.SHL
case token.SHR_ASSIGN:
op = token.SHR
case token.AND_NOT_ASSIGN:
op = token.AND_NOT
default:
panic(s.Tok)
}
var parts []string
lhs := s.Lhs[0]
switch l := lhs.(type) {
case *ast.IndexExpr:
lhsVar := c.newVariable("_lhs")
indexVar := c.newVariable("_index")
parts = append(parts, lhsVar+" = "+c.translateExpr(l.X).String()+";")
parts = append(parts, indexVar+" = "+c.translateExpr(l.Index).String()+";")
lhs = c.setType(&ast.IndexExpr{
X: c.newIdent(lhsVar, c.p.info.Types[l.X].Type),
Index: c.newIdent(indexVar, c.p.info.Types[l.Index].Type),
}, c.p.info.Types[l].Type)
case *ast.StarExpr:
lhsVar := c.newVariable("_lhs")
parts = append(parts, lhsVar+" = "+c.translateExpr(l.X).String()+";")
lhs = c.setType(&ast.StarExpr{
X: c.newIdent(lhsVar, c.p.info.Types[l.X].Type),
}, c.p.info.Types[l].Type)
case *ast.SelectorExpr:
v := hasCallVisitor{c.p.info, false}
ast.Walk(&v, l.X)
if v.hasCall {
lhsVar := c.newVariable("_lhs")
parts = append(parts, lhsVar+" = "+c.translateExpr(l.X).String()+";")
lhs = c.setType(&ast.SelectorExpr{
X: c.newIdent(lhsVar, c.p.info.Types[l.X].Type),
Sel: l.Sel,
}, c.p.info.Types[l].Type)
c.p.info.Selections[lhs.(*ast.SelectorExpr)] = c.p.info.Selections[l]
}
}
lhsType := c.p.info.Types[s.Lhs[0]].Type
parts = append(parts, c.translateAssign(lhs, c.translateExpr(c.setType(&ast.BinaryExpr{
X: lhs,
Op: op,
Y: c.setType(&ast.ParenExpr{X: s.Rhs[0]}, c.p.info.Types[s.Rhs[0]].Type),
}, lhsType)).String(), lhsType, s.Tok == token.DEFINE))
c.Printf("%s", strings.Join(parts, " "))
return
}
if s.Tok == token.DEFINE {
for _, lhs := range s.Lhs {
if !isBlank(lhs) {
obj := c.p.info.Defs[lhs.(*ast.Ident)]
if obj == nil {
obj = c.p.info.Uses[lhs.(*ast.Ident)]
}
c.setType(lhs, obj.Type())
}
}
}
switch {
case len(s.Lhs) == 1 && len(s.Rhs) == 1:
lhs := removeParens(s.Lhs[0])
if isBlank(lhs) {
v := hasCallVisitor{c.p.info, false}
ast.Walk(&v, s.Rhs[0])
if v.hasCall {
c.Printf("%s;", c.translateExpr(s.Rhs[0]).String())
}
return
}
lhsType := c.p.info.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.info.Types[s.Rhs[0]].Type.(*types.Tuple)
for i, lhs := range s.Lhs {
lhs = removeParens(lhs)
if !isBlank(lhs) {
lhsType := c.p.info.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(removeParens(s.Lhs[i])) {
v := hasCallVisitor{c.p.info, false}
ast.Walk(&v, rhs)
if v.hasCall {
c.Printf("%s;", c.translateExpr(rhs).String())
}
continue
}
lhsType := c.p.info.Types[s.Lhs[i]].Type
parts = append(parts, c.translateAssignOfExpr(c.newIdent(tmpVars[i], c.p.info.Types[s.Lhs[i]].Type), rhs, lhsType, true))
}
for i, lhs := range s.Lhs {
lhs = removeParens(lhs)
if !isBlank(lhs) {
parts = append(parts, c.translateAssign(lhs, tmpVars[i], c.p.info.Types[lhs].Type, s.Tok == token.DEFINE))
}
}
c.Printf("%s", strings.Join(parts, " "))
default:
panic("Invalid arity of AssignStmt.")
}
case *ast.IncDecStmt:
t := c.p.info.Types[s.X].Type
if iExpr, isIExpr := s.X.(*ast.IndexExpr); isIExpr {
switch u := c.p.info.Types[iExpr.X].Type.Underlying().(type) {
case *types.Array:
t = u.Elem()
case *types.Slice:
t = u.Elem()
case *types.Map:
t = u.Elem()
}
}
tok := token.ADD_ASSIGN
if s.Tok == token.DEC {
tok = token.SUB_ASSIGN
}
c.translateStmt(&ast.AssignStmt{
Lhs: []ast.Expr{s.X},
Tok: tok,
Rhs: []ast.Expr{c.newInt(1, t)},
}, label)
case *ast.DeclStmt:
c.printLabel(label)
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.info.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,
}, "")
}
case token.TYPE:
for _, spec := range decl.Specs {
o := c.p.info.Defs[spec.(*ast.TypeSpec).Name].(*types.TypeName)
c.translateType(o, false)
c.initType(o)
}
case token.CONST:
// skip, constants are inlined
}
case *ast.ExprStmt:
c.printLabel(label)
expr := c.translateExpr(s.X)
if expr != nil {
c.Printf("%s;", expr)
}
case *ast.LabeledStmt:
c.printLabel(label)
c.translateStmt(s.Stmt, s.Label.Name)
case *ast.GoStmt:
c.printLabel(label)
c.Printf("$go(%s, [%s]);", c.translateExpr(s.Call.Fun), strings.Join(c.translateArgs(c.p.info.Types[s.Call.Fun].Type.Underlying().(*types.Signature), s.Call.Args, s.Call.Ellipsis.IsValid()), ", "))
case *ast.SendStmt:
chanType := c.p.info.Types[s.Chan].Type.Underlying().(*types.Chan)
call := &ast.CallExpr{
Fun: c.newIdent("$send", types.NewSignature(nil, 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{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]", removeParens(comm.X).(*ast.UnaryExpr).X).String())
case *ast.AssignStmt:
channels = append(channels, c.formatExpr("[%e]", 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))
}
caseClauses = append(caseClauses, &ast.CaseClause{
List: []ast.Expr{c.newInt(i, types.Typ[types.Int])},
Body: clause.Body,
})
flattened = flattened || c.flattened[clause]
}
selectCall := c.setType(&ast.CallExpr{
Fun: c.newIdent("$select", types.NewSignature(nil, 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.info.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}, "")
default:
c.translateStmt(&ast.AssignStmt{Lhs: assign.Lhs, Rhs: []ast.Expr{c.newIdent(selectionVar+"[1][0]", rhsType)}, Tok: assign.Tok}, "")
}
}
}
c.translateBranchingStmt(caseClauses, true, translateCond, printCaseBodyPrefix, label, flattened)
case *ast.EmptyStmt:
// skip
default:
panic(fmt.Sprintf("Unhandled statement: %T\n", s))
}
}
func (c *funcContext) translateStmt(stmt ast.Stmt, label string) {
c.WritePos(stmt.Pos())
switch s := stmt.(type) {
case *ast.BlockStmt:
c.translateStmtList(s.List)
case *ast.IfStmt:
c.printLabel(label)
if s.Init != nil {
c.translateStmt(s.Init, "")
}
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, c.translateExpr, nil, "", c.hasGoto[s])
case *ast.SwitchStmt:
if s.Init != nil {
c.translateStmt(s.Init, "")
}
translateCond := func(cond ast.Expr) *expression {
return c.translateExpr(cond)
}
if s.Tag != nil {
refVar := c.newVariable("_ref")
c.Printf("%s = %s;", refVar, c.translateExpr(s.Tag))
translateCond = func(cond ast.Expr) *expression {
refIdent := c.newIdent(refVar, c.p.info.Types[s.Tag].Type)
return c.translateExpr(&ast.BinaryExpr{
X: refIdent,
Op: token.EQL,
Y: cond,
})
}
}
c.translateBranchingStmt(s.Body.List, true, translateCond, nil, label, c.hasGoto[s])
case *ast.TypeSwitchStmt:
if s.Init != nil {
c.translateStmt(s.Init, "")
}
var expr ast.Expr
var typeSwitchVar string
switch a := s.Assign.(type) {
case *ast.AssignStmt:
expr = a.Rhs[0].(*ast.TypeAssertExpr).X
typeSwitchVar = c.newVariable(a.Lhs[0].(*ast.Ident).Name)
for _, caseClause := range s.Body.List {
c.p.objectVars[c.p.info.Implicits[caseClause]] = typeSwitchVar
}
case *ast.ExprStmt:
expr = a.X.(*ast.TypeAssertExpr).X
}
refVar := c.newVariable("_ref")
typeVar := c.newVariable("_type")
c.Printf("%s = %s;", refVar, c.translateExpr(expr))
c.Printf("%s = %s !== null ? %s.constructor : null;", typeVar, refVar, refVar)
translateCond := func(cond ast.Expr) *expression {
return c.formatExpr("%s", c.typeCheck(typeVar, c.p.info.Types[cond].Type))
}
printCaseBodyPrefix := func(conds []ast.Expr) {
if typeSwitchVar == "" {
return
}
value := refVar
if len(conds) == 1 {
t := c.p.info.Types[conds[0]].Type
if _, isInterface := t.Underlying().(*types.Interface); !isInterface && !types.Identical(t, types.Typ[types.UntypedNil]) {
value += ".$val"
}
}
c.Printf("%s = %s;", typeSwitchVar, value)
}
c.translateBranchingStmt(s.Body.List, true, translateCond, printCaseBodyPrefix, label, c.hasGoto[s])
case *ast.ForStmt:
if s.Init != nil {
c.translateStmt(s.Init, "")
}
cond := "true"
if s.Cond != nil {
cond = c.translateExpr(s.Cond).String()
}
c.translateLoopingStmt(cond, s.Body, nil, func() {
if s.Post != nil {
c.translateStmt(s.Post, "")
}
}, label, c.hasGoto[s])
case *ast.RangeStmt:
refVar := c.newVariable("_ref")
c.Printf("%s = %s;", refVar, c.translateExpr(s.X))
iVar := c.newVariable("_i")
c.Printf("%s = 0;", iVar)
switch t := c.p.info.Types[s.X].Type.Underlying().(type) {
case *types.Basic:
runeVar := c.newVariable("_rune")
c.translateLoopingStmt(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.hasGoto[s])
case *types.Map:
keysVar := c.newVariable("_keys")
c.Printf("%s = $keys(%s);", keysVar, refVar)
c.translateLoopingStmt(iVar+" < "+keysVar+".length", s.Body, func() {
entryVar := c.newVariable("_entry")
c.Printf("%s = %s[%s[%s]];", entryVar, refVar, keysVar, iVar)
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.hasGoto[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()
}
c.translateLoopingStmt(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) {
indexExpr := &ast.IndexExpr{
X: c.newIdent(refVar, t),
Index: c.newIdent(iVar, types.Typ[types.Int]),
}
c.p.info.Types[indexExpr] = types.TypeAndValue{Type: elemType}
c.Printf("%s", c.translateAssign(s.Value, c.translateImplicitConversion(indexExpr, elemType).String(), elemType, s.Tok == token.DEFINE))
}
}, func() {
c.Printf("%s++;", iVar)
}, label, c.hasGoto[s])
case *types.Chan:
c.printLabel(label)
// skip
default:
panic("")
}
case *ast.BranchStmt:
c.printLabel(label)
labelSuffix := ""
data := c.flowDatas[""]
if s.Label != nil {
labelSuffix = " " + s.Label.Name
data = c.flowDatas[s.Label.Name]
}
switch s.Tok {
case token.BREAK:
c.PrintCond(data.endCase == 0, fmt.Sprintf("break%s;", labelSuffix), fmt.Sprintf("$s = %d; continue;", data.endCase))
case token.CONTINUE:
data.postStmt()
c.PrintCond(data.beginCase == 0, fmt.Sprintf("continue%s;", labelSuffix), fmt.Sprintf("$s = %d; continue;", data.beginCase))
case token.GOTO:
c.PrintCond(false, "goto "+s.Label.Name, fmt.Sprintf("$s = %d; continue;", c.labelCases[s.Label.Name]))
case token.FALLTHROUGH:
// handled in CaseClause
default:
panic("Unhandled branch statment: " + s.Tok.String())
}
case *ast.ReturnStmt:
c.printLabel(label)
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,
}, "")
}
results = c.resultNames
}
switch len(results) {
case 0:
c.Printf("return;")
case 1:
if c.sig.Results().Len() > 1 {
c.Printf("return %s;", c.translateExpr(results[0]))
break
}
v := c.translateImplicitConversion(results[0], c.sig.Results().At(0).Type())
c.delayedOutput = nil
c.Printf("return %s;", v)
default:
values := make([]string, len(results))
for i, result := range results {
values[i] = c.translateImplicitConversion(result, c.sig.Results().At(i).Type()).String()
}
c.delayedOutput = nil
c.Printf("return [%s];", strings.Join(values, ", "))
}
case *ast.DeferStmt:
c.printLabel(label)
isBuiltin := false
isJs := false
switch fun := s.Call.Fun.(type) {
case *ast.Ident:
var builtin *types.Builtin
builtin, isBuiltin = c.p.info.Uses[fun].(*types.Builtin)
if isBuiltin && builtin.Name() == "recover" {
c.Printf("$deferred.push({ fun: $recover, args: [] });")
return
}
case *ast.SelectorExpr:
isJs = isJsPackage(c.p.info.Uses[fun.Sel].Pkg())
}
if isBuiltin || isJs {
args := make([]ast.Expr, len(s.Call.Args))
for i, arg := range s.Call.Args {
args[i] = c.newIdent(c.newVariable("_arg"), c.p.info.Types[arg].Type)
}
call := c.translateExpr(&ast.CallExpr{
Fun: s.Call.Fun,
Args: args,
Ellipsis: s.Call.Ellipsis,
})
c.Printf("$deferred.push({ fun: function(%s) { %s; }, args: [%s] });", strings.Join(c.translateExprSlice(args, nil), ", "), call, strings.Join(c.translateExprSlice(s.Call.Args, nil), ", "))
return
}
sig := c.p.info.Types[s.Call.Fun].Type.Underlying().(*types.Signature)
args := strings.Join(c.translateArgs(sig, s.Call.Args, s.Call.Ellipsis.IsValid()), ", ")
if s, isSelector := s.Call.Fun.(*ast.SelectorExpr); isSelector {
obj := c.p.info.Uses[s.Sel]
if !obj.Exported() {
c.p.dependencies[obj] = true
}
recv := c.translateExpr(s.X)
sel, ok := c.p.info.Selections[s]
if ok && sel.Kind() == types.MethodVal && isWrapped(sel.Recv()) {
recv = c.formatParenExpr("new %s(%s)", c.typeName(sel.Recv()), recv)
}
c.Printf(`$deferred.push({ recv: %s, method: "%s", args: [%s] });`, recv, s.Sel.Name, args)
return
}
c.Printf("$deferred.push({ fun: %s, args: [%s] });", c.translateExpr(s.Call.Fun), args)
case *ast.AssignStmt:
c.printLabel(label)
if s.Tok != token.ASSIGN && s.Tok != token.DEFINE {
var op token.Token
switch s.Tok {
case token.ADD_ASSIGN:
op = token.ADD
case token.SUB_ASSIGN:
op = token.SUB
case token.MUL_ASSIGN:
op = token.MUL
case token.QUO_ASSIGN:
op = token.QUO
case token.REM_ASSIGN:
op = token.REM
case token.AND_ASSIGN:
op = token.AND
case token.OR_ASSIGN:
op = token.OR
case token.XOR_ASSIGN:
op = token.XOR
case token.SHL_ASSIGN:
op = token.SHL
case token.SHR_ASSIGN:
op = token.SHR
case token.AND_NOT_ASSIGN:
op = token.AND_NOT
default:
panic(s.Tok)
}
var parts []string
lhs := s.Lhs[0]
switch l := lhs.(type) {
case *ast.IndexExpr:
lhsVar := c.newVariable("_lhs")
indexVar := c.newVariable("_index")
parts = append(parts, lhsVar+" = "+c.translateExpr(l.X).String()+";")
parts = append(parts, indexVar+" = "+c.translateExpr(l.Index).String()+";")
lhs = &ast.IndexExpr{
X: c.newIdent(lhsVar, c.p.info.Types[l.X].Type),
Index: c.newIdent(indexVar, c.p.info.Types[l.Index].Type),
}
c.p.info.Types[lhs] = c.p.info.Types[l]
case *ast.StarExpr:
lhsVar := c.newVariable("_lhs")
parts = append(parts, lhsVar+" = "+c.translateExpr(l.X).String()+";")
lhs = &ast.StarExpr{
X: c.newIdent(lhsVar, c.p.info.Types[l.X].Type),
}
c.p.info.Types[lhs] = c.p.info.Types[l]
case *ast.SelectorExpr:
v := hasCallVisitor{c.p.info, false}
ast.Walk(&v, l.X)
if v.hasCall {
lhsVar := c.newVariable("_lhs")
parts = append(parts, lhsVar+" = "+c.translateExpr(l.X).String()+";")
lhs = &ast.SelectorExpr{
X: c.newIdent(lhsVar, c.p.info.Types[l.X].Type),
Sel: l.Sel,
}
c.p.info.Types[lhs] = c.p.info.Types[l]
c.p.info.Selections[lhs.(*ast.SelectorExpr)] = c.p.info.Selections[l]
}
}
parenExpr := &ast.ParenExpr{X: s.Rhs[0]}
c.p.info.Types[parenExpr] = c.p.info.Types[s.Rhs[0]]
binaryExpr := &ast.BinaryExpr{
X: lhs,
Op: op,
Y: parenExpr,
}
lhsType := c.p.info.Types[s.Lhs[0]]
c.p.info.Types[binaryExpr] = lhsType
parts = append(parts, c.translateAssign(lhs, c.translateExpr(binaryExpr).String(), lhsType.Type, s.Tok == token.DEFINE))
c.Printf("%s", strings.Join(parts, " "))
return
}
if s.Tok == token.DEFINE {
for _, lhs := range s.Lhs {
if !isBlank(lhs) {
obj := c.p.info.Defs[lhs.(*ast.Ident)]
if obj == nil {
obj = c.p.info.Uses[lhs.(*ast.Ident)]
}
c.p.info.Types[lhs] = types.TypeAndValue{Type: obj.Type()}
}
}
}
switch {
case len(s.Lhs) == 1 && len(s.Rhs) == 1:
lhs := removeParens(s.Lhs[0])
if isBlank(lhs) {
v := hasCallVisitor{c.p.info, false}
ast.Walk(&v, s.Rhs[0])
if v.hasCall {
c.Printf("%s;", c.translateExpr(s.Rhs[0]).String())
}
return
}
lhsType := c.p.info.Types[s.Lhs[0]].Type
c.Printf("%s", c.translateAssign(lhs, c.translateImplicitConversion(s.Rhs[0], lhsType).String(), 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.info.Types[s.Rhs[0]].Type.(*types.Tuple)
for i, lhs := range s.Lhs {
lhs = removeParens(lhs)
if !isBlank(lhs) {
lhsType := c.p.info.Types[s.Lhs[i]].Type
out += " " + c.translateAssign(lhs, c.translateImplicitConversion(c.newIdent(fmt.Sprintf("%s[%d]", tupleVar, i), tuple.At(i).Type()), lhsType).String(), 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(removeParens(s.Lhs[i])) {
v := hasCallVisitor{c.p.info, false}
ast.Walk(&v, rhs)
if v.hasCall {
c.Printf("%s;", c.translateExpr(rhs).String())
}
continue
}
lhsType := c.p.info.Types[s.Lhs[i]].Type
parts = append(parts, c.translateAssign(c.newIdent(tmpVars[i], c.p.info.Types[s.Lhs[i]].Type), c.translateImplicitConversion(rhs, lhsType).String(), lhsType, true))
}
for i, lhs := range s.Lhs {
lhs = removeParens(lhs)
if !isBlank(lhs) {
parts = append(parts, c.translateAssign(lhs, tmpVars[i], c.p.info.Types[lhs].Type, s.Tok == token.DEFINE))
}
}
c.Printf("%s", strings.Join(parts, " "))
default:
panic("Invalid arity of AssignStmt.")
}
case *ast.IncDecStmt:
t := c.p.info.Types[s.X].Type
if iExpr, isIExpr := s.X.(*ast.IndexExpr); isIExpr {
switch u := c.p.info.Types[iExpr.X].Type.Underlying().(type) {
case *types.Array:
t = u.Elem()
case *types.Slice:
t = u.Elem()
case *types.Map:
t = u.Elem()
}
}
tok := token.ADD_ASSIGN
if s.Tok == token.DEC {
tok = token.SUB_ASSIGN
}
one := &ast.BasicLit{
Kind: token.INT,
Value: "1",
}
c.p.info.Types[one] = types.TypeAndValue{Type: t, Value: exact.MakeInt64(1)}
c.translateStmt(&ast.AssignStmt{
Lhs: []ast.Expr{s.X},
Tok: tok,
Rhs: []ast.Expr{one},
}, label)
case *ast.ExprStmt:
c.printLabel(label)
c.Printf("%s;", c.translateExpr(s.X).String())
case *ast.DeclStmt:
c.printLabel(label)
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.info.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,
}, "")
}
case token.TYPE:
for _, spec := range decl.Specs {
o := c.p.info.Defs[spec.(*ast.TypeSpec).Name].(*types.TypeName)
c.translateType(o, false)
c.initType(o)
}
case token.CONST:
// skip, constants are inlined
}
case *ast.LabeledStmt:
c.printLabel(label)
c.translateStmt(s.Stmt, s.Label.Name)
case *ast.SelectStmt:
c.printLabel(label)
c.Printf(`$notSupported("select");`)
case *ast.GoStmt:
c.printLabel(label)
c.Printf(`$notSupported("go");`)
case *ast.SendStmt:
c.printLabel(label)
c.Printf(`$notSupported("send");`)
case *ast.EmptyStmt:
// skip
default:
panic(fmt.Sprintf("Unhandled statement: %T\n", s))
}
}
func (cdd *CDD) builtin(b *types.Builtin, args []ast.Expr) (fun, recv string) {
name := b.Name()
switch name {
case "len":
switch t := underlying(cdd.exprType(args[0])).(type) {
case *types.Slice, *types.Basic: // Basic == String
return "len", ""
case *types.Array:
return "", strconv.FormatInt(t.Len(), 10)
case *types.Chan:
return "clen", ""
default:
notImplemented(ast.NewIdent("len"), t)
}
case "cap":
switch t := underlying(cdd.exprType(args[0])).(type) {
case *types.Slice:
return "cap", ""
case *types.Chan:
return "ccap", ""
default:
notImplemented(ast.NewIdent("cap"), t)
}
case "copy":
switch t := underlying(cdd.exprType(args[1])).(type) {
case *types.Basic: // string
return "STRCPY", ""
case *types.Slice:
typ, dim, _ := cdd.TypeStr(t.Elem())
return "SLICPY", typ + dimFuncPtr("", dim)
default:
panic(t)
}
case "new":
typ, dim, _ := cdd.TypeStr(cdd.exprType(args[0]))
args[0] = nil
return "NEW", typ + dimFuncPtr("", dim)
case "make":
a0t := cdd.exprType(args[0])
args[0] = nil
switch t := underlying(a0t).(type) {
case *types.Slice:
typ, dim, _ := cdd.TypeStr(t.Elem())
name := "MAKESLI"
if len(args) == 3 {
name = "MAKESLIC"
}
return name, typ + dimFuncPtr("", dim)
case *types.Chan:
typ, dim, _ := cdd.TypeStr(t.Elem())
typ += dimFuncPtr("", dim)
if len(args) == 1 {
typ += ", 0"
}
return "MAKECHAN", typ
case *types.Map:
typ, dim, _ := cdd.TypeStr(t.Key())
k := typ + dimFuncPtr("", dim)
typ, dim, _ = cdd.TypeStr(t.Elem())
e := typ + dimFuncPtr("", dim)
name := "MAKEMAP"
if len(args) == 2 {
name = "MAKEMAPC"
}
return name, k + ", " + e
default:
notImplemented(ast.NewIdent(name))
}
}
return name, ""
}