func (p *exporter) value(x exact.Value) {
if trace {
p.tracef("value { ")
defer p.tracef("} ")
}
switch kind := x.Kind(); kind {
case exact.Bool:
tag := falseTag
if exact.BoolVal(x) {
tag = trueTag
}
p.int(tag)
case exact.Int:
if i, ok := exact.Int64Val(x); ok {
p.int(int64Tag)
p.int64(i)
return
}
p.int(floatTag)
p.float(x)
case exact.Float:
p.int(fractionTag)
p.fraction(x)
case exact.Complex:
p.int(complexTag)
p.fraction(exact.Real(x))
p.fraction(exact.Imag(x))
case exact.String:
p.int(stringTag)
p.string(exact.StringVal(x))
default:
panic(fmt.Sprintf("unexpected value kind %d", kind))
}
}
// checkPrintf checks a call to a formatted print routine such as Printf.
// call.Args[formatIndex] is (well, should be) the format argument.
func (f *File) checkPrintf(call *ast.CallExpr, name string, formatIndex int) {
if formatIndex >= len(call.Args) {
f.Bad(call.Pos(), "too few arguments in call to", name)
return
}
lit := f.pkg.types[call.Args[formatIndex]].Value
if lit == nil {
if *verbose {
f.Warn(call.Pos(), "can't check non-constant format in call to", name)
}
return
}
if lit.Kind() != exact.String {
f.Badf(call.Pos(), "constant %v not a string in call to %s", lit, name)
return
}
format := exact.StringVal(lit)
firstArg := formatIndex + 1 // Arguments are immediately after format string.
if !strings.Contains(format, "%") {
if len(call.Args) > firstArg {
f.Badf(call.Pos(), "no formatting directive in %s call", name)
}
return
}
// Hard part: check formats against args.
argNum := firstArg
indexed := false
for i, w := 0, 0; i < len(format); i += w {
w = 1
if format[i] == '%' {
state := f.parsePrintfVerb(call, name, format[i:], firstArg, argNum)
if state == nil {
return
}
w = len(state.format)
if state.indexed {
indexed = true
}
if !f.okPrintfArg(call, state) { // One error per format is enough.
return
}
if len(state.argNums) > 0 {
// Continue with the next sequential argument.
argNum = state.argNums[len(state.argNums)-1] + 1
}
}
}
// Dotdotdot is hard.
if call.Ellipsis.IsValid() && argNum >= len(call.Args)-1 {
return
}
// If the arguments were direct indexed, we assume the programmer knows what's up.
// Otherwise, there should be no leftover arguments.
if !indexed && argNum != len(call.Args) {
expect := argNum - firstArg
numArgs := len(call.Args) - firstArg
f.Badf(call.Pos(), "wrong number of args for format in %s call: %d needed but %d args", name, expect, numArgs)
}
}
//ranges through config file and checks all expressions.
// prints result messages to stdout
func (c *checker) CheckAll() ([]CheckResult, error) {
result := []CheckResult{}
cnf, err := conf.ReadConfigFile(c.configFile)
if err != nil {
return nil, err
}
for _, section := range cnf.GetSections() {
if section == "default" {
continue
}
expr, _ := cnf.GetString(section, "expr")
_, r, err := types.Eval(expr, c.pkg, c.sc)
if err != nil {
fmt.Fprintln(os.Stderr, err)
continue
}
cr := &CheckResult{
Name: section,
}
var m string
if exact.BoolVal(r) {
m, err = cnf.GetString(section, "true")
if err != nil {
continue
}
} else {
m, err = cnf.GetString(section, "false")
if err != nil {
continue
}
}
val, err := cnf.GetString(section, "val")
if err == nil {
t, v, err := types.Eval(val, c.pkg, c.sc)
if err == nil {
if types.Identical(t, types.Typ[types.UntypedFloat]) || types.Identical(t, types.Typ[types.Float64]) {
x, _ := exact.Float64Val(v)
cr.Value = x
}
}
}
owner, err := cnf.GetString(section, "owner")
if err == nil {
cr.Owner = owner
} else {
cr.Owner = "unknown"
}
_, msg, err := types.Eval(m, c.pkg, c.sc)
if err != nil {
cr.Message = m
} else {
cr.Message = exact.StringVal(msg)
}
result = append(result, *cr)
}
return result, nil
}
// constValue returns the value of the constant with the
// dynamic type tag appropriate for c.Type().
func constValue(c *ssa.Const) value {
if c.IsNil() {
return zero(c.Type()) // typed nil
}
if t, ok := c.Type().Underlying().(*types.Basic); ok {
// TODO(adonovan): eliminate untyped constants from SSA form.
switch t.Kind() {
case types.Bool, types.UntypedBool:
return exact.BoolVal(c.Value)
case types.Int, types.UntypedInt:
// Assume sizeof(int) is same on host and target.
return int(c.Int64())
case types.Int8:
return int8(c.Int64())
case types.Int16:
return int16(c.Int64())
case types.Int32, types.UntypedRune:
return int32(c.Int64())
case types.Int64:
return c.Int64()
case types.Uint:
// Assume sizeof(uint) is same on host and target.
return uint(c.Uint64())
case types.Uint8:
return uint8(c.Uint64())
case types.Uint16:
return uint16(c.Uint64())
case types.Uint32:
return uint32(c.Uint64())
case types.Uint64:
return c.Uint64()
case types.Uintptr:
// Assume sizeof(uintptr) is same on host and target.
return uintptr(c.Uint64())
case types.Float32:
return float32(c.Float64())
case types.Float64, types.UntypedFloat:
return c.Float64()
case types.Complex64:
return complex64(c.Complex128())
case types.Complex128, types.UntypedComplex:
return c.Complex128()
case types.String, types.UntypedString:
if c.Value.Kind() == exact.String {
return exact.StringVal(c.Value)
}
return string(rune(c.Int64()))
}
}
panic(fmt.Sprintf("constValue: %s", c))
}
func (c *Const) Name() string {
var s string
if c.Value.Kind() == exact.String {
s = exact.StringVal(c.Value)
const max = 20
if len(s) > max {
s = s[:max-3] + "..." // abbreviate
}
s = strconv.Quote(s)
} else {
s = c.Value.String()
}
return s + ":" + c.typ.String()
}
func (l *Literal) Name() string {
var s string
if l.Value.Kind() == exact.String {
s = exact.StringVal(l.Value)
const maxLit = 20
if len(s) > maxLit {
s = s[:maxLit-3] + "..." // abbreviate
}
s = strconv.Quote(s)
} else {
s = l.Value.String()
}
return s + ":" + l.Type_.String()
}
func (c *Const) valstring() string {
if c.Value == nil {
return "nil"
} else if c.Value.Kind() == exact.String {
s := exact.StringVal(c.Value)
const max = 20
if len(s) > max {
s = s[:max-3] + "..." // abbreviate
}
return strconv.Quote(s)
} else {
return c.Value.String()
}
}
func (c *funcContext) identifierConstant(expr ast.Expr) (string, bool) {
val := c.p.info.Types[expr].Value
if val == nil {
return "", false
}
s := exact.StringVal(val)
if len(s) == 0 {
return "", false
}
for i, c := range s {
if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (i > 0 && c >= '0' && c <= '9') || c == '_' || c == '$') {
return "", false
}
}
return s, true
}
func (c *Const) RelString(from *types.Package) string {
var s string
if c.Value == nil {
s = "nil"
} else if c.Value.Kind() == exact.String {
s = exact.StringVal(c.Value)
const max = 20
// TODO(adonovan): don't cut a rune in half.
if len(s) > max {
s = s[:max-3] + "..." // abbreviate
}
s = strconv.Quote(s)
} else {
s = c.Value.String()
}
return s + ":" + relType(c.Type(), from)
}
func ext۰reflect۰rtype۰MethodByName(a *analysis, cgn *cgnode) {
// If we have access to the callsite,
// and the argument is a string constant,
// return only that method.
var name string
if site := cgn.callersite; site != nil {
if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
name = exact.StringVal(c.Value)
}
}
a.addConstraint(&rtypeMethodByNameConstraint{
cgn: cgn,
name: name,
t: a.funcParams(cgn.obj),
result: a.funcResults(cgn.obj),
})
}
func analyzeNapParam(pkg *types.Package, info *types.Info, c *ast.CallExpr) (string, bool) {
sel, ok := c.Fun.(*ast.SelectorExpr)
if !ok {
return "", false
}
xType := info.Types[sel.X]
if xType.Type == nil {
return "", false
}
if xType.Type.String() != "github.com/Logiraptor/nap.Request" {
return "", false
}
// printNode(c)
nameTV := info.Types[c.Args[0]]
return exact.StringVal(nameTV.Value), true
}
func Test(t *testing.T) {
switch runtime.GOOS {
case "windows":
t.Skipf("skipping test on %q (no /usr/bin/diff)", runtime.GOOS)
}
conf := loader.Config{
Fset: token.NewFileSet(),
ParserMode: parser.ParseComments,
SourceImports: true,
}
// Each entry is a single-file package.
// (Multi-file packages aren't interesting for this test.)
// Order matters: each non-template package is processed using
// the preceding template package.
for _, filename := range []string{
"testdata/A.template",
"testdata/A1.go",
"testdata/A2.go",
"testdata/B.template",
"testdata/B1.go",
"testdata/C.template",
"testdata/C1.go",
"testdata/D.template",
"testdata/D1.go",
"testdata/E.template",
"testdata/E1.go",
"testdata/bad_type.template",
"testdata/no_before.template",
"testdata/no_after_return.template",
"testdata/type_mismatch.template",
"testdata/expr_type_mismatch.template",
} {
pkgname := strings.TrimSuffix(filepath.Base(filename), ".go")
if err := conf.CreateFromFilenames(pkgname, filename); err != nil {
t.Fatal(err)
}
}
iprog, err := conf.Load()
if err != nil {
t.Fatal(err)
}
var xform *eg.Transformer
for _, info := range iprog.Created {
file := info.Files[0]
filename := iprog.Fset.File(file.Pos()).Name() // foo.go
if strings.HasSuffix(filename, "template") {
// a new template
shouldFail, _ := info.Pkg.Scope().Lookup("shouldFail").(*types.Const)
xform, err = eg.NewTransformer(iprog.Fset, info, *verboseFlag)
if err != nil {
if shouldFail == nil {
t.Errorf("NewTransformer(%s): %s", filename, err)
} else if want := exact.StringVal(shouldFail.Val()); !strings.Contains(err.Error(), want) {
t.Errorf("NewTransformer(%s): got error %q, want error %q", filename, err, want)
}
} else if shouldFail != nil {
t.Errorf("NewTransformer(%s) succeeded unexpectedly; want error %q",
filename, shouldFail.Val())
}
continue
}
if xform == nil {
t.Errorf("%s: no previous template", filename)
continue
}
// apply previous template to this package
n := xform.Transform(&info.Info, info.Pkg, file)
if n == 0 {
t.Errorf("%s: no matches", filename)
continue
}
got := filename + "t" // foo.got
golden := filename + "lden" // foo.golden
// Write actual output to foo.got.
if err := eg.WriteAST(iprog.Fset, got, file); err != nil {
t.Error(err)
}
defer os.Remove(got)
// Compare foo.got with foo.golden.
var cmd *exec.Cmd
switch runtime.GOOS {
case "plan9":
cmd = exec.Command("/bin/diff", "-c", golden, got)
default:
cmd = exec.Command("/usr/bin/diff", "-u", golden, got)
}
buf := new(bytes.Buffer)
cmd.Stdout = buf
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
t.Errorf("eg tests for %s failed: %s.\n%s\n", filename, err, buf)
if *updateFlag {
t.Logf("Updating %s...", golden)
if err := exec.Command("/bin/cp", got, golden).Run(); err != nil {
t.Errorf("Update failed: %s", err)
}
}
}
}
}
func (c *PkgContext) translateExpr(expr ast.Expr) string {
exprType := c.info.Types[expr]
if value, valueFound := c.info.Values[expr]; valueFound {
basic := types.Typ[types.String]
if value.Kind() != exact.String { // workaround for bug in go/types
basic = exprType.Underlying().(*types.Basic)
}
switch {
case basic.Info()&types.IsBoolean != 0:
return strconv.FormatBool(exact.BoolVal(value))
case basic.Info()&types.IsInteger != 0:
if is64Bit(basic) {
d, _ := exact.Uint64Val(value)
return fmt.Sprintf("new %s(%d, %d)", c.typeName(exprType), d>>32, d&(1<<32-1))
}
d, _ := exact.Int64Val(value)
return strconv.FormatInt(d, 10)
case basic.Info()&types.IsFloat != 0:
f, _ := exact.Float64Val(value)
return strconv.FormatFloat(f, 'g', -1, 64)
case basic.Info()&types.IsComplex != 0:
r, _ := exact.Float64Val(exact.Real(value))
i, _ := exact.Float64Val(exact.Imag(value))
if basic.Kind() == types.UntypedComplex {
exprType = types.Typ[types.Complex128]
}
return fmt.Sprintf("new %s(%s, %s)", c.typeName(exprType), strconv.FormatFloat(r, 'g', -1, 64), strconv.FormatFloat(i, 'g', -1, 64))
case basic.Info()&types.IsString != 0:
buffer := bytes.NewBuffer(nil)
for _, r := range []byte(exact.StringVal(value)) {
switch r {
case '\b':
buffer.WriteString(`\b`)
case '\f':
buffer.WriteString(`\f`)
case '\n':
buffer.WriteString(`\n`)
case '\r':
buffer.WriteString(`\r`)
case '\t':
buffer.WriteString(`\t`)
case '\v':
buffer.WriteString(`\v`)
case '"':
buffer.WriteString(`\"`)
case '\\':
buffer.WriteString(`\\`)
default:
if r < 0x20 || r > 0x7E {
fmt.Fprintf(buffer, `\x%02X`, r)
continue
}
buffer.WriteByte(r)
}
}
return `"` + buffer.String() + `"`
default:
panic("Unhandled constant type: " + basic.String())
}
}
switch e := expr.(type) {
case *ast.CompositeLit:
if ptrType, isPointer := exprType.(*types.Pointer); isPointer {
exprType = ptrType.Elem()
}
collectIndexedElements := func(elementType types.Type) []string {
elements := make([]string, 0)
i := 0
zero := c.zeroValue(elementType)
for _, element := range e.Elts {
if kve, isKve := element.(*ast.KeyValueExpr); isKve {
key, _ := exact.Int64Val(c.info.Values[kve.Key])
i = int(key)
element = kve.Value
}
for len(elements) <= i {
elements = append(elements, zero)
}
elements[i] = c.translateExprToType(element, elementType)
i++
}
return elements
}
switch t := exprType.Underlying().(type) {
case *types.Array:
elements := collectIndexedElements(t.Elem())
if len(elements) != 0 {
zero := c.zeroValue(t.Elem())
for len(elements) < int(t.Len()) {
elements = append(elements, zero)
}
return createListComposite(t.Elem(), elements)
}
return fmt.Sprintf("Go$makeArray(%s, %d, function() { return %s; })", toArrayType(t.Elem()), t.Len(), c.zeroValue(t.Elem()))
case *types.Slice:
return fmt.Sprintf("new %s(%s)", c.typeName(exprType), createListComposite(t.Elem(), collectIndexedElements(t.Elem())))
case *types.Map:
elements := make([]string, len(e.Elts)*2)
for i, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
elements[i*2] = c.translateExprToType(kve.Key, t.Key())
elements[i*2+1] = c.translateExprToType(kve.Value, t.Elem())
}
return fmt.Sprintf("new %s([%s])", c.typeName(exprType), strings.Join(elements, ", "))
case *types.Struct:
elements := make([]string, t.NumFields())
isKeyValue := true
if len(e.Elts) != 0 {
_, isKeyValue = e.Elts[0].(*ast.KeyValueExpr)
}
if !isKeyValue {
for i, element := range e.Elts {
elements[i] = c.translateExprToType(element, t.Field(i).Type())
}
}
if isKeyValue {
for i := range elements {
elements[i] = c.zeroValue(t.Field(i).Type())
}
for _, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
for j := range elements {
if kve.Key.(*ast.Ident).Name == t.Field(j).Name() {
elements[j] = c.translateExprToType(kve.Value, t.Field(j).Type())
break
}
}
}
}
if named, isNamed := exprType.(*types.Named); isNamed {
return fmt.Sprintf("new %s(%s)", c.objectName(named.Obj()), strings.Join(elements, ", "))
}
structVar := c.newVariable("_struct")
c.translateTypeSpec(&ast.TypeSpec{
Name: c.newIdent(structVar, t),
Type: e.Type,
})
return fmt.Sprintf("new %s(%s)", structVar, strings.Join(elements, ", "))
default:
panic(fmt.Sprintf("Unhandled CompositeLit type: %T\n", t))
}
case *ast.FuncLit:
return strings.TrimSpace(string(c.CatchOutput(func() {
c.newScope(func() {
params := c.translateParams(e.Type)
closurePrefix := "("
closureSuffix := ")"
if len(c.escapingVars) != 0 {
list := strings.Join(c.escapingVars, ", ")
closurePrefix = "(function(" + list + ") { return "
closureSuffix = "; })(" + list + ")"
}
c.Printf("%sfunction(%s) {", closurePrefix, strings.Join(params, ", "))
c.Indent(func() {
c.translateFunctionBody(e.Body.List, exprType.(*types.Signature))
})
c.Printf("}%s", closureSuffix)
})
})))
case *ast.UnaryExpr:
switch e.Op {
case token.AND:
switch c.info.Types[e.X].Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
default:
if _, isComposite := e.X.(*ast.CompositeLit); isComposite {
return fmt.Sprintf("Go$newDataPointer(%s, %s)", c.translateExpr(e.X), c.typeName(c.info.Types[e]))
}
closurePrefix := ""
closureSuffix := ""
if len(c.escapingVars) != 0 {
list := strings.Join(c.escapingVars, ", ")
closurePrefix = "(function(" + list + ") { return "
closureSuffix = "; })(" + list + ")"
}
vVar := c.newVariable("v")
return fmt.Sprintf("%snew %s(function() { return %s; }, function(%s) { %s; })%s", closurePrefix, c.typeName(exprType), c.translateExpr(e.X), vVar, c.translateAssign(e.X, vVar), closureSuffix)
}
case token.ARROW:
return "undefined"
}
t := c.info.Types[e.X]
basic := t.Underlying().(*types.Basic)
op := e.Op.String()
switch e.Op {
case token.ADD:
return c.translateExpr(e.X)
case token.SUB:
if is64Bit(basic) {
x := c.newVariable("x")
return fmt.Sprintf("(%s = %s, new %s(-%s.high, -%s.low))", x, c.translateExpr(e.X), c.typeName(t), x, x)
}
if basic.Info()&types.IsComplex != 0 {
x := c.newVariable("x")
return fmt.Sprintf("(%s = %s, new %s(-%s.real, -%s.imag))", x, c.translateExpr(e.X), c.typeName(t), x, x)
}
case token.XOR:
if is64Bit(basic) {
x := c.newVariable("x")
return fmt.Sprintf("(%s = %s, new %s(~%s.high, ~%s.low >>> 0))", x, c.translateExpr(e.X), c.typeName(t), x, x)
}
op = "~"
}
return fixNumber(fmt.Sprintf("%s%s", op, c.translateExpr(e.X)), basic)
case *ast.BinaryExpr:
if e.Op == token.NEQ {
return fmt.Sprintf("!(%s)", c.translateExpr(&ast.BinaryExpr{
X: e.X,
Op: token.EQL,
Y: e.Y,
}))
}
t := c.info.Types[e.X]
t2 := c.info.Types[e.Y]
_, isInterface := t2.Underlying().(*types.Interface)
if isInterface {
t = t2
}
if basic, isBasic := t.Underlying().(*types.Basic); isBasic && basic.Info()&types.IsNumeric != 0 {
if is64Bit(basic) {
var expr string
switch e.Op {
case token.MUL:
return fmt.Sprintf("Go$mul64(%s, %s)", c.translateExpr(e.X), c.translateExpr(e.Y))
case token.QUO:
return fmt.Sprintf("Go$div64(%s, %s, false)", c.translateExpr(e.X), c.translateExpr(e.Y))
case token.REM:
return fmt.Sprintf("Go$div64(%s, %s, true)", c.translateExpr(e.X), c.translateExpr(e.Y))
case token.SHL:
return fmt.Sprintf("Go$shiftLeft64(%s, %s)", c.translateExpr(e.X), c.flatten64(e.Y))
case token.SHR:
return fmt.Sprintf("Go$shiftRight%s(%s, %s)", toJavaScriptType(basic), c.translateExpr(e.X), c.flatten64(e.Y))
case token.EQL:
expr = "x.high === y.high && x.low === y.low"
case token.LSS:
expr = "x.high < y.high || (x.high === y.high && x.low < y.low)"
case token.LEQ:
expr = "x.high < y.high || (x.high === y.high && x.low <= y.low)"
case token.GTR:
expr = "x.high > y.high || (x.high === y.high && x.low > y.low)"
case token.GEQ:
expr = "x.high > y.high || (x.high === y.high && x.low >= y.low)"
case token.ADD, token.SUB:
expr = fmt.Sprintf("new %s(x.high %s y.high, x.low %s y.low)", c.typeName(t), e.Op, e.Op)
case token.AND, token.OR, token.XOR:
expr = fmt.Sprintf("new %s(x.high %s y.high, (x.low %s y.low) >>> 0)", c.typeName(t), e.Op, e.Op)
case token.AND_NOT:
expr = fmt.Sprintf("new %s(x.high &~ y.high, (x.low &~ y.low) >>> 0)", c.typeName(t))
default:
panic(e.Op)
}
x := c.newVariable("x")
y := c.newVariable("y")
expr = strings.Replace(expr, "x.", x+".", -1)
expr = strings.Replace(expr, "y.", y+".", -1)
return fmt.Sprintf("(%s = %s, %s = %s, %s)", x, c.translateExpr(e.X), y, c.translateExpr(e.Y), expr)
}
if basic.Info()&types.IsComplex != 0 {
var expr string
switch e.Op {
case token.EQL:
expr = "x.real === y.real && x.imag === y.imag"
case token.ADD, token.SUB:
expr = fmt.Sprintf("new %s(x.real %s y.real, x.imag %s y.imag)", c.typeName(t), e.Op, e.Op)
case token.MUL:
expr = fmt.Sprintf("new %s(x.real * y.real - x.imag * y.imag, x.real * y.imag + x.imag * y.real)", c.typeName(t))
case token.QUO:
return fmt.Sprintf("Go$divComplex(%s, %s)", c.translateExpr(e.X), c.translateExpr(e.Y))
default:
panic(e.Op)
}
x := c.newVariable("x")
y := c.newVariable("y")
expr = strings.Replace(expr, "x.", x+".", -1)
expr = strings.Replace(expr, "y.", y+".", -1)
return fmt.Sprintf("(%s = %s, %s = %s, %s)", x, c.translateExpr(e.X), y, c.translateExpr(e.Y), expr)
}
switch e.Op {
case token.EQL:
return fmt.Sprintf("%s === %s", c.translateExpr(e.X), c.translateExpr(e.Y))
case token.LSS, token.LEQ, token.GTR, token.GEQ:
return fmt.Sprintf("%s %s %s", c.translateExpr(e.X), e.Op, c.translateExpr(e.Y))
case token.ADD, token.SUB:
return fixNumber(fmt.Sprintf("%s %s %s", c.translateExpr(e.X), e.Op, c.translateExpr(e.Y)), basic)
case token.MUL:
if basic.Kind() == types.Int32 {
x := c.newVariable("x")
y := c.newVariable("y")
return fmt.Sprintf("(%s = %s, %s = %s, (((%s >>> 16 << 16) * %s >> 0) + (%s << 16 >>> 16) * %s) >> 0)", x, c.translateExpr(e.X), y, c.translateExpr(e.Y), x, y, x, y)
}
if basic.Kind() == types.Uint32 || basic.Kind() == types.Uintptr {
x := c.newVariable("x")
y := c.newVariable("y")
return fmt.Sprintf("(%s = %s, %s = %s, (((%s >>> 16 << 16) * %s >>> 0) + (%s << 16 >>> 16) * %s) >>> 0)", x, c.translateExpr(e.X), y, c.translateExpr(e.Y), x, y, x, y)
}
return fixNumber(fmt.Sprintf("%s * %s", c.translateExpr(e.X), c.translateExpr(e.Y)), basic)
case token.QUO:
value := fmt.Sprintf("%s / %s", c.translateExpr(e.X), c.translateExpr(e.Y))
if basic.Info()&types.IsInteger != 0 {
value = "(Go$obj = " + value + `, (Go$obj === Go$obj && Go$obj !== 1/0 && Go$obj !== -1/0) ? Go$obj : Go$throwRuntimeError("integer divide by zero"))`
}
switch basic.Kind() {
case types.Int, types.Uint:
return "(" + value + " >> 0)" // cut off decimals
default:
return fixNumber(value, basic)
}
case token.REM:
return fmt.Sprintf(`(Go$obj = %s %% %s, Go$obj === Go$obj ? Go$obj : Go$throwRuntimeError("integer divide by zero"))`, c.translateExpr(e.X), c.translateExpr(e.Y))
case token.SHL, token.SHR:
op := e.Op.String()
if e.Op == token.SHR && basic.Info()&types.IsUnsigned != 0 {
op = ">>>"
}
if c.info.Values[e.Y] != nil {
return fixNumber(fmt.Sprintf("%s %s %s", c.translateExpr(e.X), op, c.translateExpr(e.Y)), basic)
}
if e.Op == token.SHR && basic.Info()&types.IsUnsigned == 0 {
return fixNumber(fmt.Sprintf("(%s >> Go$min(%s, 31))", c.translateExpr(e.X), c.translateExpr(e.Y)), basic)
}
y := c.newVariable("y")
return fixNumber(fmt.Sprintf("(%s = %s, %s < 32 ? (%s %s %s) : 0)", y, c.translateExprToType(e.Y, types.Typ[types.Uint]), y, c.translateExpr(e.X), op, y), basic)
case token.AND, token.OR, token.XOR:
return fixNumber(fmt.Sprintf("(%s %s %s)", c.translateExpr(e.X), e.Op, c.translateExpr(e.Y)), basic)
case token.AND_NOT:
return fixNumber(fmt.Sprintf("(%s &~ %s)", c.translateExpr(e.X), c.translateExpr(e.Y)), basic)
default:
panic(e.Op)
}
}
switch e.Op {
case token.ADD, token.LSS, token.LEQ, token.GTR, token.GEQ, token.LAND, token.LOR:
return fmt.Sprintf("%s %s %s", c.translateExpr(e.X), e.Op, c.translateExpr(e.Y))
case token.EQL:
switch u := t.Underlying().(type) {
case *types.Struct:
x := c.newVariable("x")
y := c.newVariable("y")
var conds []string
for i := 0; i < u.NumFields(); i++ {
field := u.Field(i)
if field.Name() == "_" {
continue
}
conds = append(conds, c.translateExpr(&ast.BinaryExpr{
X: c.newIdent(x+"."+field.Name(), field.Type()),
Op: token.EQL,
Y: c.newIdent(y+"."+field.Name(), field.Type()),
}))
}
if len(conds) == 0 {
conds = []string{"true"}
}
return fmt.Sprintf("(%s = %s, %s = %s, %s)", x, c.translateExpr(e.X), y, c.translateExpr(e.Y), strings.Join(conds, " && "))
case *types.Interface:
return fmt.Sprintf("Go$interfaceIsEqual(%s, %s)", c.translateExprToType(e.X, t), c.translateExprToType(e.Y, t))
case *types.Array:
return fmt.Sprintf("Go$arrayIsEqual(%s, %s)", c.translateExpr(e.X), c.translateExpr(e.Y))
case *types.Pointer:
xUnary, xIsUnary := e.X.(*ast.UnaryExpr)
yUnary, yIsUnary := e.Y.(*ast.UnaryExpr)
if xIsUnary && xUnary.Op == token.AND && yIsUnary && yUnary.Op == token.AND {
xIndex, xIsIndex := xUnary.X.(*ast.IndexExpr)
yIndex, yIsIndex := yUnary.X.(*ast.IndexExpr)
if xIsIndex && yIsIndex {
return fmt.Sprintf("Go$sliceIsEqual(%s, %s, %s, %s)", c.translateExpr(xIndex.X), c.flatten64(xIndex.Index), c.translateExpr(yIndex.X), c.flatten64(yIndex.Index))
}
}
switch u.Elem().Underlying().(type) {
case *types.Struct, *types.Interface:
return c.translateExprToType(e.X, t) + " === " + c.translateExprToType(e.Y, t)
case *types.Array:
return fmt.Sprintf("Go$arrayIsEqual(%s, %s)", c.translateExprToType(e.X, t), c.translateExprToType(e.Y, t))
default:
return fmt.Sprintf("Go$pointerIsEqual(%s, %s)", c.translateExprToType(e.X, t), c.translateExprToType(e.Y, t))
}
default:
return c.translateExprToType(e.X, t) + " === " + c.translateExprToType(e.Y, t)
}
default:
panic(e.Op)
}
case *ast.ParenExpr:
return fmt.Sprintf("(%s)", c.translateExpr(e.X))
case *ast.IndexExpr:
xType := c.info.Types[e.X]
if ptr, isPointer := xType.(*types.Pointer); isPointer {
xType = ptr.Elem()
}
switch t := xType.Underlying().(type) {
case *types.Array:
return fmt.Sprintf("%s[%s]", c.translateExpr(e.X), c.flatten64(e.Index))
case *types.Slice:
sliceVar := c.newVariable("_slice")
indexVar := c.newVariable("_index")
return fmt.Sprintf(`(%s = %s, %s = %s, (%s >= 0 && %s < %s.length) ? %s.array[%s.offset + %s] : Go$throwRuntimeError("index out of range"))`, sliceVar, c.translateExpr(e.X), indexVar, c.flatten64(e.Index), indexVar, indexVar, sliceVar, sliceVar, sliceVar, indexVar)
case *types.Map:
key := c.makeKey(e.Index, t.Key())
if _, isTuple := exprType.(*types.Tuple); isTuple {
return fmt.Sprintf(`(Go$obj = (%s || false)[%s], Go$obj !== undefined ? [Go$obj.v, true] : [%s, false])`, c.translateExpr(e.X), key, c.zeroValue(t.Elem()))
}
return fmt.Sprintf(`(Go$obj = (%s || false)[%s], Go$obj !== undefined ? Go$obj.v : %s)`, c.translateExpr(e.X), key, c.zeroValue(t.Elem()))
case *types.Basic:
return fmt.Sprintf("%s.charCodeAt(%s)", c.translateExpr(e.X), c.flatten64(e.Index))
default:
panic(fmt.Sprintf("Unhandled IndexExpr: %T\n", t))
}
case *ast.SliceExpr:
b, isBasic := c.info.Types[e.X].(*types.Basic)
isString := isBasic && b.Info()&types.IsString != 0
slice := c.translateExprToType(e.X, exprType)
if e.High == nil {
if e.Low == nil {
return slice
}
if isString {
return fmt.Sprintf("%s.substring(%s)", slice, c.flatten64(e.Low))
}
return fmt.Sprintf("Go$subslice(%s, %s)", slice, c.flatten64(e.Low))
}
low := "0"
if e.Low != nil {
low = c.flatten64(e.Low)
}
if isString {
return fmt.Sprintf("%s.substring(%s, %s)", slice, low, c.flatten64(e.High))
}
if e.Max != nil {
return fmt.Sprintf("Go$subslice(%s, %s, %s, %s)", slice, low, c.flatten64(e.High), c.flatten64(e.Max))
}
return fmt.Sprintf("Go$subslice(%s, %s, %s)", slice, low, c.flatten64(e.High))
case *ast.SelectorExpr:
sel := c.info.Selections[e]
parameterName := func(v *types.Var) string {
if v.Anonymous() || v.Name() == "" {
return c.newVariable("param")
}
return c.newVariable(v.Name())
}
makeParametersList := func() []string {
params := sel.Obj().Type().(*types.Signature).Params()
names := make([]string, params.Len())
for i := 0; i < params.Len(); i++ {
names[i] = parameterName(params.At(i))
}
return names
}
switch sel.Kind() {
case types.FieldVal:
return c.translateExpr(e.X) + "." + translateSelection(sel)
case types.MethodVal:
parameters := makeParametersList()
recv := c.newVariable("_recv")
return fmt.Sprintf("(%s = %s, function(%s) { return %s.%s(%s); })", recv, c.translateExpr(e.X), strings.Join(parameters, ", "), recv, e.Sel.Name, strings.Join(parameters, ", "))
case types.MethodExpr:
recv := "recv"
if isWrapped(sel.Recv()) {
recv = fmt.Sprintf("(new %s(recv))", c.typeName(sel.Recv()))
}
parameters := makeParametersList()
return fmt.Sprintf("(function(%s) { return %s.%s(%s); })", strings.Join(append([]string{"recv"}, parameters...), ", "), recv, sel.Obj().(*types.Func).Name(), strings.Join(parameters, ", "))
case types.PackageObj:
return fmt.Sprintf("%s.%s", c.translateExpr(e.X), e.Sel.Name)
}
panic("")
case *ast.CallExpr:
plainFun := e.Fun
for {
if p, isParen := plainFun.(*ast.ParenExpr); isParen {
plainFun = p.X
continue
}
break
}
switch f := plainFun.(type) {
case *ast.Ident:
switch o := c.info.Objects[f].(type) {
case *types.Builtin:
switch o.Name() {
case "new":
t := c.info.Types[e].(*types.Pointer)
if types.IsIdentical(t.Elem().Underlying(), types.Typ[types.Uintptr]) {
return "new Uint8Array(8)"
}
switch t.Elem().Underlying().(type) {
case *types.Struct, *types.Array:
return c.zeroValue(t.Elem())
default:
return fmt.Sprintf("Go$newDataPointer(%s, %s)", c.zeroValue(t.Elem()), c.typeName(t))
}
case "make":
switch t2 := c.info.Types[e.Args[0]].Underlying().(type) {
case *types.Slice:
if len(e.Args) == 3 {
return fmt.Sprintf("Go$subslice(new %s(Go$makeArray(%s, %s, function() { return %s; })), 0, %s)", c.typeName(c.info.Types[e.Args[0]]), toArrayType(t2.Elem()), c.translateExprToType(e.Args[2], types.Typ[types.Int]), c.zeroValue(t2.Elem()), c.translateExprToType(e.Args[1], types.Typ[types.Int]))
}
return fmt.Sprintf("new %s(Go$makeArray(%s, %s, function() { return %s; }))", c.typeName(c.info.Types[e.Args[0]]), toArrayType(t2.Elem()), c.translateExprToType(e.Args[1], types.Typ[types.Int]), c.zeroValue(t2.Elem()))
default:
args := []string{"undefined"}
for _, arg := range e.Args[1:] {
args = append(args, c.translateExpr(arg))
}
return fmt.Sprintf("new %s(%s)", c.typeName(c.info.Types[e.Args[0]]), strings.Join(args, ", "))
}
case "len":
arg := c.translateExpr(e.Args[0])
switch argType := c.info.Types[e.Args[0]].Underlying().(type) {
case *types.Basic, *types.Slice:
return arg + ".length"
case *types.Pointer:
return fmt.Sprintf("(%s, %d)", arg, argType.Elem().(*types.Array).Len())
case *types.Map:
return fmt.Sprintf("(Go$obj = %s, Go$obj !== null ? Go$keys(Go$obj).length : 0)", arg)
case *types.Chan:
return "0"
// length of array is constant
default:
panic(fmt.Sprintf("Unhandled len type: %T\n", argType))
}
case "cap":
arg := c.translateExpr(e.Args[0])
switch argType := c.info.Types[e.Args[0]].Underlying().(type) {
case *types.Slice:
return arg + ".capacity"
case *types.Pointer:
return fmt.Sprintf("(%s, %d)", arg, argType.Elem().(*types.Array).Len())
case *types.Chan:
return "0"
// capacity of array is constant
default:
panic(fmt.Sprintf("Unhandled cap type: %T\n", argType))
}
case "panic":
return fmt.Sprintf("throw new Go$Panic(%s)", c.translateExprToType(e.Args[0], types.NewInterface(nil, nil)))
case "append":
if e.Ellipsis.IsValid() {
return fmt.Sprintf("Go$append(%s, %s)", c.translateExpr(e.Args[0]), c.translateExprToType(e.Args[1], exprType))
}
sliceType := exprType.Underlying().(*types.Slice)
toAppend := createListComposite(sliceType.Elem(), c.translateExprSlice(e.Args[1:], sliceType.Elem()))
return fmt.Sprintf("Go$append(%s, new %s(%s))", c.translateExpr(e.Args[0]), c.typeName(exprType), toAppend)
case "delete":
return fmt.Sprintf(`delete (%s || Go$Map.Go$nil)[%s]`, c.translateExpr(e.Args[0]), c.makeKey(e.Args[1], c.info.Types[e.Args[0]].Underlying().(*types.Map).Key()))
case "copy":
return fmt.Sprintf("Go$copy(%s, %s)", c.translateExprToType(e.Args[0], types.NewSlice(types.Typ[types.Byte])), c.translateExprToType(e.Args[1], types.NewSlice(types.Typ[types.Byte])))
case "print", "println":
return fmt.Sprintf("console.log(%s)", strings.Join(c.translateExprSlice(e.Args, nil), ", "))
case "complex":
return fmt.Sprintf("new %s(%s, %s)", c.typeName(c.info.Types[e]), c.translateExpr(e.Args[0]), c.translateExpr(e.Args[1]))
case "real":
return c.translateExpr(e.Args[0]) + ".real"
case "imag":
return c.translateExpr(e.Args[0]) + ".imag"
case "recover":
return "Go$recover()"
case "close":
return `Go$throwRuntimeError("not supported by GopherJS: close")`
default:
panic(fmt.Sprintf("Unhandled builtin: %s\n", o.Name()))
}
case *types.TypeName: // conversion
if basic, isBasic := o.Type().Underlying().(*types.Basic); isBasic && !types.IsIdentical(c.info.Types[e.Args[0]], types.Typ[types.UnsafePointer]) {
return fixNumber(c.translateExprToType(e.Args[0], o.Type()), basic)
}
return c.translateExprToType(e.Args[0], o.Type())
}
case *ast.FuncType: // conversion
return c.translateExprToType(e.Args[0], c.info.Types[plainFun])
}
funType := c.info.Types[plainFun]
sig, isSig := funType.Underlying().(*types.Signature)
if !isSig { // conversion
if c.pkg.Path() == "reflect" {
if call, isCall := e.Args[0].(*ast.CallExpr); isCall && types.IsIdentical(c.info.Types[call.Fun], types.Typ[types.UnsafePointer]) {
if named, isNamed := funType.(*types.Pointer).Elem().(*types.Named); isNamed {
return c.translateExpr(call.Args[0]) + "." + named.Obj().Name() // unsafe conversion
}
}
}
return c.translateExprToType(e.Args[0], funType)
}
var fun string
switch f := plainFun.(type) {
case *ast.SelectorExpr:
sel := c.info.Selections[f]
switch sel.Kind() {
case types.MethodVal:
methodsRecvType := sel.Obj().(*types.Func).Type().(*types.Signature).Recv().Type()
_, pointerExpected := methodsRecvType.(*types.Pointer)
_, isPointer := sel.Recv().Underlying().(*types.Pointer)
_, isStruct := sel.Recv().Underlying().(*types.Struct)
_, isArray := sel.Recv().Underlying().(*types.Array)
if pointerExpected && !isPointer && !isStruct && !isArray {
target := c.translateExpr(f.X)
vVar := c.newVariable("v")
fun = fmt.Sprintf("(new %s(function() { return %s; }, function(%s) { %s = %s; })).%s", c.typeName(methodsRecvType), target, vVar, target, vVar, f.Sel.Name)
break
}
if isWrapped(sel.Recv()) {
fun = fmt.Sprintf("(new %s(%s)).%s", c.typeName(sel.Recv()), c.translateExpr(f.X), f.Sel.Name)
break
}
fun = fmt.Sprintf("%s.%s", c.translateExpr(f.X), f.Sel.Name)
case types.FieldVal, types.MethodExpr, types.PackageObj:
fun = c.translateExpr(f)
default:
panic("")
}
default:
fun = c.translateExpr(plainFun)
}
if len(e.Args) == 1 {
if tuple, isTuple := c.info.Types[e.Args[0]].(*types.Tuple); isTuple {
args := make([]ast.Expr, tuple.Len())
for i := range args {
args[i] = c.newIdent(fmt.Sprintf("Go$tuple[%d]", i), tuple.At(i).Type())
}
return fmt.Sprintf("(Go$tuple = %s, %s(%s))", c.translateExpr(e.Args[0]), fun, c.translateArgs(sig, args, false))
}
}
return fmt.Sprintf("%s(%s)", fun, c.translateArgs(sig, e.Args, e.Ellipsis.IsValid()))
case *ast.StarExpr:
if c1, isCall := e.X.(*ast.CallExpr); isCall && len(c1.Args) == 1 {
if c2, isCall := c1.Args[0].(*ast.CallExpr); isCall && len(c2.Args) == 1 && types.IsIdentical(c.info.Types[c2.Fun], types.Typ[types.UnsafePointer]) {
if unary, isUnary := c2.Args[0].(*ast.UnaryExpr); isUnary && unary.Op == token.AND {
return c.translateExpr(unary.X) // unsafe conversion
}
}
}
switch exprType.Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
}
return c.translateExpr(e.X) + ".Go$get()"
case *ast.TypeAssertExpr:
if e.Type == nil {
return c.translateExpr(e.X)
}
t := c.info.Types[e.Type]
check := "Go$obj !== null && " + c.typeCheck("Go$obj.constructor", t)
value := "Go$obj"
if _, isInterface := t.Underlying().(*types.Interface); !isInterface {
value += ".Go$val"
}
if _, isTuple := exprType.(*types.Tuple); isTuple {
return fmt.Sprintf("(Go$obj = %s, %s ? [%s, true] : [%s, false])", c.translateExpr(e.X), check, value, c.zeroValue(c.info.Types[e.Type]))
}
return fmt.Sprintf("(Go$obj = %s, %s ? %s : Go$typeAssertionFailed(Go$obj))", c.translateExpr(e.X), check, value)
case *ast.Ident:
if e.Name == "_" {
panic("Tried to translate underscore identifier.")
}
switch o := c.info.Objects[e].(type) {
case *types.PkgName:
return c.pkgVars[o.Pkg().Path()]
case *types.Var, *types.Const:
return c.objectName(o)
case *types.Func:
return c.objectName(o)
case *types.TypeName:
return c.typeName(o.Type())
case *types.Nil:
return c.zeroValue(c.info.Types[e])
case nil:
return e.Name
default:
panic(fmt.Sprintf("Unhandled object: %T\n", o))
}
case nil:
return ""
default:
panic(fmt.Sprintf("Unhandled expression: %T\n", e))
}
}
func Write(pkg *types.Package, out io.Writer, sizes types.Sizes) {
fmt.Fprintf(out, "package %s\n", pkg.Name())
e := &exporter{pkg: pkg, imports: make(map[*types.Package]bool), out: out}
for _, imp := range pkg.Imports() {
e.addImport(imp)
}
for _, name := range pkg.Scope().Names() {
obj := pkg.Scope().Lookup(name)
_, isTypeName := obj.(*types.TypeName)
if obj.Exported() || isTypeName {
e.toExport = append(e.toExport, obj)
}
}
for i := 0; i < len(e.toExport); i++ {
switch o := e.toExport[i].(type) {
case *types.TypeName:
fmt.Fprintf(out, "type %s %s\n", e.makeName(o), e.makeType(o.Type().Underlying()))
if _, isInterface := o.Type().Underlying().(*types.Interface); !isInterface {
writeMethods := func(t types.Type) {
methods := types.NewMethodSet(t)
for i := 0; i < methods.Len(); i++ {
m := methods.At(i)
if len(m.Index()) > 1 {
continue // method of embedded field
}
out.Write([]byte("func (? " + e.makeType(m.Recv()) + ") " + e.makeName(m.Obj()) + e.makeSignature(m.Type()) + "\n"))
}
}
writeMethods(o.Type())
writeMethods(types.NewPointer(o.Type()))
}
case *types.Func:
out.Write([]byte("func " + e.makeName(o) + e.makeSignature(o.Type()) + "\n"))
case *types.Const:
optType := ""
basic, isBasic := o.Type().(*types.Basic)
if !isBasic || basic.Info()&types.IsUntyped == 0 {
optType = " " + e.makeType(o.Type())
}
basic = o.Type().Underlying().(*types.Basic)
var val string
switch {
case basic.Info()&types.IsBoolean != 0:
val = strconv.FormatBool(exact.BoolVal(o.Val()))
case basic.Info()&types.IsInteger != 0:
if basic.Kind() == types.Uint64 {
d, _ := exact.Uint64Val(o.Val())
val = fmt.Sprintf("%#x", d)
break
}
d, _ := exact.Int64Val(o.Val())
if basic.Kind() == types.UntypedRune {
switch {
case d < 0 || d > unicode.MaxRune:
val = fmt.Sprintf("('\\x00' + %d)", d)
case d > 0xffff:
val = fmt.Sprintf("'\\U%08x'", d)
default:
val = fmt.Sprintf("'\\u%04x'", d)
}
break
}
val = fmt.Sprintf("%#x", d)
case basic.Info()&types.IsFloat != 0:
f, _ := exact.Float64Val(o.Val())
val = strconv.FormatFloat(f, 'b', -1, 64)
case basic.Info()&types.IsComplex != 0:
r, _ := exact.Float64Val(exact.Real(o.Val()))
i, _ := exact.Float64Val(exact.Imag(o.Val()))
val = fmt.Sprintf("(%s+%si)", strconv.FormatFloat(r, 'b', -1, 64), strconv.FormatFloat(i, 'b', -1, 64))
case basic.Info()&types.IsString != 0:
val = fmt.Sprintf("%#v", exact.StringVal(o.Val()))
default:
panic("Unhandled constant type: " + basic.String())
}
out.Write([]byte("const " + e.makeName(o) + optType + " = " + val + "\n"))
case *types.Var:
out.Write([]byte("var " + e.makeName(o) + " " + e.makeType(o.Type()) + "\n"))
default:
panic(fmt.Sprintf("Unhandled object: %T\n", o))
}
}
fmt.Fprintf(out, "$$\n")
}
func (c *funcContext) translateExpr(expr ast.Expr) *expression {
exprType := c.p.info.Types[expr].Type
if value := c.p.info.Types[expr].Value; value != nil {
basic := types.Typ[types.String]
if value.Kind() != exact.String { // workaround for bug in go/types
basic = exprType.Underlying().(*types.Basic)
}
switch {
case basic.Info()&types.IsBoolean != 0:
return c.formatExpr("%s", strconv.FormatBool(exact.BoolVal(value)))
case basic.Info()&types.IsInteger != 0:
if is64Bit(basic) {
d, _ := exact.Uint64Val(value)
if basic.Kind() == types.Int64 {
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatInt(int64(d)>>32, 10), strconv.FormatUint(d&(1<<32-1), 10))
}
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatUint(d>>32, 10), strconv.FormatUint(d&(1<<32-1), 10))
}
d, _ := exact.Int64Val(value)
return c.formatExpr("%s", strconv.FormatInt(d, 10))
case basic.Info()&types.IsFloat != 0:
f, _ := exact.Float64Val(value)
return c.formatExpr("%s", strconv.FormatFloat(f, 'g', -1, 64))
case basic.Info()&types.IsComplex != 0:
r, _ := exact.Float64Val(exact.Real(value))
i, _ := exact.Float64Val(exact.Imag(value))
if basic.Kind() == types.UntypedComplex {
exprType = types.Typ[types.Complex128]
}
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatFloat(r, 'g', -1, 64), strconv.FormatFloat(i, 'g', -1, 64))
case basic.Info()&types.IsString != 0:
return c.formatExpr("%s", encodeString(exact.StringVal(value)))
default:
panic("Unhandled constant type: " + basic.String())
}
}
switch e := expr.(type) {
case *ast.CompositeLit:
if ptrType, isPointer := exprType.(*types.Pointer); isPointer {
exprType = ptrType.Elem()
}
collectIndexedElements := func(elementType types.Type) []string {
elements := make([]string, 0)
i := 0
zero := c.zeroValue(elementType)
for _, element := range e.Elts {
if kve, isKve := element.(*ast.KeyValueExpr); isKve {
key, _ := exact.Int64Val(c.p.info.Types[kve.Key].Value)
i = int(key)
element = kve.Value
}
for len(elements) <= i {
elements = append(elements, zero)
}
elements[i] = c.translateImplicitConversion(element, elementType).String()
i++
}
return elements
}
switch t := exprType.Underlying().(type) {
case *types.Array:
elements := collectIndexedElements(t.Elem())
if len(elements) != 0 {
zero := c.zeroValue(t.Elem())
for len(elements) < int(t.Len()) {
elements = append(elements, zero)
}
return c.formatExpr(`go$toNativeArray("%s", [%s])`, typeKind(t.Elem()), strings.Join(elements, ", "))
}
return c.formatExpr(`go$makeNativeArray("%s", %d, function() { return %s; })`, typeKind(t.Elem()), int(t.Len()), c.zeroValue(t.Elem()))
case *types.Slice:
return c.formatExpr("new %s([%s])", c.typeName(exprType), strings.Join(collectIndexedElements(t.Elem()), ", "))
case *types.Map:
mapVar := c.newVariable("_map")
keyVar := c.newVariable("_key")
assignments := ""
for _, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
assignments += c.formatExpr(`%s = %s, %s[%s] = { k: %s, v: %s }, `, keyVar, c.translateImplicitConversion(kve.Key, t.Key()), mapVar, c.makeKey(c.newIdent(keyVar, t.Key()), t.Key()), keyVar, c.translateImplicitConversion(kve.Value, t.Elem())).String()
}
return c.formatExpr("(%s = new Go$Map(), %s%s)", mapVar, assignments, mapVar)
case *types.Struct:
elements := make([]string, t.NumFields())
isKeyValue := true
if len(e.Elts) != 0 {
_, isKeyValue = e.Elts[0].(*ast.KeyValueExpr)
}
if !isKeyValue {
for i, element := range e.Elts {
elements[i] = c.translateImplicitConversion(element, t.Field(i).Type()).String()
}
}
if isKeyValue {
for i := range elements {
elements[i] = c.zeroValue(t.Field(i).Type())
}
for _, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
for j := range elements {
if kve.Key.(*ast.Ident).Name == t.Field(j).Name() {
elements[j] = c.translateImplicitConversion(kve.Value, t.Field(j).Type()).String()
break
}
}
}
}
return c.formatExpr("new %s.Ptr(%s)", c.typeName(exprType), strings.Join(elements, ", "))
default:
panic(fmt.Sprintf("Unhandled CompositeLit type: %T\n", t))
}
case *ast.FuncLit:
params, body := c.translateFunction(e.Type, exprType.(*types.Signature), e.Body.List)
if len(c.escapingVars) != 0 {
list := strings.Join(c.escapingVars, ", ")
return c.formatExpr("(function(%s) { return function(%s) {\n%s%s}; })(%s)", list, strings.Join(params, ", "), string(body), strings.Repeat("\t", c.p.indentation), list)
}
return c.formatExpr("(function(%s) {\n%s%s})", strings.Join(params, ", "), string(body), strings.Repeat("\t", c.p.indentation))
case *ast.UnaryExpr:
switch e.Op {
case token.AND:
switch c.p.info.Types[e.X].Type.Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
default:
if _, isComposite := e.X.(*ast.CompositeLit); isComposite {
return c.formatExpr("go$newDataPointer(%e, %s)", e.X, c.typeName(c.p.info.Types[e].Type))
}
closurePrefix := ""
closureSuffix := ""
if len(c.escapingVars) != 0 {
list := strings.Join(c.escapingVars, ", ")
closurePrefix = "(function(" + list + ") { return "
closureSuffix = "; })(" + list + ")"
}
vVar := c.newVariable("v")
return c.formatExpr("%snew %s(function() { return %e; }, function(%s) { %s; })%s", closurePrefix, c.typeName(exprType), e.X, vVar, c.translateAssign(e.X, vVar), closureSuffix)
}
case token.ARROW:
return c.formatExpr("undefined")
}
t := c.p.info.Types[e.X].Type
basic := t.Underlying().(*types.Basic)
switch e.Op {
case token.ADD:
return c.translateExpr(e.X)
case token.SUB:
switch {
case is64Bit(basic):
return c.formatExpr("new %1s(-%2h, -%2l)", c.typeName(t), e.X)
case basic.Info()&types.IsComplex != 0:
return c.formatExpr("new %1s(-%2r, -%2i)", c.typeName(t), e.X)
case basic.Info()&types.IsUnsigned != 0:
return c.fixNumber(c.formatExpr("-%e", e.X), basic)
default:
return c.formatExpr("-%e", e.X)
}
case token.XOR:
if is64Bit(basic) {
return c.formatExpr("new %1s(~%2h, ~%2l >>> 0)", c.typeName(t), e.X)
}
return c.fixNumber(c.formatExpr("~%e", e.X), basic)
case token.NOT:
x := c.translateExpr(e.X)
if x.String() == "true" {
return c.formatExpr("false")
}
if x.String() == "false" {
return c.formatExpr("true")
}
return c.formatExpr("!%s", x)
default:
panic(e.Op)
}
case *ast.BinaryExpr:
if e.Op == token.NEQ {
return c.formatExpr("!(%s)", c.translateExpr(&ast.BinaryExpr{
X: e.X,
Op: token.EQL,
Y: e.Y,
}))
}
t := c.p.info.Types[e.X].Type
t2 := c.p.info.Types[e.Y].Type
_, isInterface := t2.Underlying().(*types.Interface)
if isInterface {
t = t2
}
if basic, isBasic := t.Underlying().(*types.Basic); isBasic && basic.Info()&types.IsNumeric != 0 {
if is64Bit(basic) {
switch e.Op {
case token.MUL:
return c.formatExpr("go$mul64(%e, %e)", e.X, e.Y)
case token.QUO:
return c.formatExpr("go$div64(%e, %e, false)", e.X, e.Y)
case token.REM:
return c.formatExpr("go$div64(%e, %e, true)", e.X, e.Y)
case token.SHL:
return c.formatExpr("go$shiftLeft64(%e, %f)", e.X, e.Y)
case token.SHR:
return c.formatExpr("go$shiftRight%s(%e, %f)", toJavaScriptType(basic), e.X, e.Y)
case token.EQL:
return c.formatExpr("(%1h === %2h && %1l === %2l)", e.X, e.Y)
case token.LSS:
return c.formatExpr("(%1h < %2h || (%1h === %2h && %1l < %2l))", e.X, e.Y)
case token.LEQ:
return c.formatExpr("(%1h < %2h || (%1h === %2h && %1l <= %2l))", e.X, e.Y)
case token.GTR:
return c.formatExpr("(%1h > %2h || (%1h === %2h && %1l > %2l))", e.X, e.Y)
case token.GEQ:
return c.formatExpr("(%1h > %2h || (%1h === %2h && %1l >= %2l))", e.X, e.Y)
case token.ADD, token.SUB:
return c.formatExpr("new %3s(%1h %4t %2h, %1l %4t %2l)", e.X, e.Y, c.typeName(t), e.Op)
case token.AND, token.OR, token.XOR:
return c.formatExpr("new %3s(%1h %4t %2h, (%1l %4t %2l) >>> 0)", e.X, e.Y, c.typeName(t), e.Op)
case token.AND_NOT:
return c.formatExpr("new %3s(%1h &~ %2h, (%1l &~ %2l) >>> 0)", e.X, e.Y, c.typeName(t))
default:
panic(e.Op)
}
}
if basic.Info()&types.IsComplex != 0 {
switch e.Op {
case token.EQL:
if basic.Kind() == types.Complex64 {
return c.formatExpr("(go$float32IsEqual(%1r, %2r) && go$float32IsEqual(%1i, %2i))", e.X, e.Y)
}
return c.formatExpr("(%1r === %2r && %1i === %2i)", e.X, e.Y)
case token.ADD, token.SUB:
return c.formatExpr("new %3s(%1r %4t %2r, %1i %4t %2i)", e.X, e.Y, c.typeName(t), e.Op)
case token.MUL:
return c.formatExpr("new %3s(%1r * %2r - %1i * %2i, %1r * %2i + %1i * %2r)", e.X, e.Y, c.typeName(t))
case token.QUO:
return c.formatExpr("go$divComplex(%e, %e)", e.X, e.Y)
default:
panic(e.Op)
}
}
switch e.Op {
case token.EQL:
if basic.Kind() == types.Float32 {
return c.formatParenExpr("go$float32IsEqual(%e, %e)", e.X, e.Y)
}
return c.formatParenExpr("%e === %e", e.X, e.Y)
case token.LSS, token.LEQ, token.GTR, token.GEQ:
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.ADD, token.SUB:
if basic.Info()&types.IsInteger != 0 {
return c.fixNumber(c.formatExpr("%e %t %e", e.X, e.Op, e.Y), basic)
}
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.MUL:
switch basic.Kind() {
case types.Int32, types.Int:
return c.formatParenExpr("(((%1e >>> 16 << 16) * %2e >> 0) + (%1e << 16 >>> 16) * %2e) >> 0", e.X, e.Y)
case types.Uint32, types.Uint, types.Uintptr:
return c.formatParenExpr("(((%1e >>> 16 << 16) * %2e >>> 0) + (%1e << 16 >>> 16) * %2e) >>> 0", e.X, e.Y)
case types.Float32, types.Float64:
return c.formatExpr("%e * %e", e.X, e.Y)
default:
return c.fixNumber(c.formatExpr("%e * %e", e.X, e.Y), basic)
}
case token.QUO:
if basic.Info()&types.IsInteger != 0 {
// cut off decimals
shift := ">>"
if basic.Info()&types.IsUnsigned != 0 {
shift = ">>>"
}
return c.formatExpr(`(%1s = %2e / %3e, (%1s === %1s && %1s !== 1/0 && %1s !== -1/0) ? %1s %4s 0 : go$throwRuntimeError("integer divide by zero"))`, c.newVariable("_q"), e.X, e.Y, shift)
}
return c.formatExpr("%e / %e", e.X, e.Y)
case token.REM:
return c.formatExpr(`(%1s = %2e %% %3e, %1s === %1s ? %1s : go$throwRuntimeError("integer divide by zero"))`, c.newVariable("_r"), e.X, e.Y)
case token.SHL, token.SHR:
op := e.Op.String()
if e.Op == token.SHR && basic.Info()&types.IsUnsigned != 0 {
op = ">>>"
}
if c.p.info.Types[e.Y].Value != nil {
return c.fixNumber(c.formatExpr("%e %s %e", e.X, op, e.Y), basic)
}
if e.Op == token.SHR && basic.Info()&types.IsUnsigned == 0 {
return c.fixNumber(c.formatParenExpr("%e >> go$min(%e, 31)", e.X, e.Y), basic)
}
y := c.newVariable("y")
return c.fixNumber(c.formatExpr("(%s = %s, %s < 32 ? (%e %s %s) : 0)", y, c.translateImplicitConversion(e.Y, types.Typ[types.Uint]), y, e.X, op, y), basic)
case token.AND, token.OR:
if basic.Info()&types.IsUnsigned != 0 {
return c.formatParenExpr("(%e %t %e) >>> 0", e.X, e.Op, e.Y)
}
return c.formatParenExpr("%e %t %e", e.X, e.Op, e.Y)
case token.AND_NOT:
return c.formatParenExpr("%e & ~%e", e.X, e.Y)
case token.XOR:
return c.fixNumber(c.formatParenExpr("%e ^ %e", e.X, e.Y), basic)
default:
panic(e.Op)
}
}
switch e.Op {
case token.ADD, token.LSS, token.LEQ, token.GTR, token.GEQ:
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.LAND:
x := c.translateExpr(e.X)
y := c.translateExpr(e.Y)
if x.String() == "false" {
return c.formatExpr("false")
}
return c.formatExpr("%s && %s", x, y)
case token.LOR:
x := c.translateExpr(e.X)
y := c.translateExpr(e.Y)
if x.String() == "true" {
return c.formatExpr("true")
}
return c.formatExpr("%s || %s", x, y)
case token.EQL:
switch u := t.Underlying().(type) {
case *types.Struct:
x := c.newVariable("x")
y := c.newVariable("y")
var conds []string
for i := 0; i < u.NumFields(); i++ {
field := u.Field(i)
if field.Name() == "_" {
continue
}
conds = append(conds, c.translateExpr(&ast.BinaryExpr{
X: c.newIdent(x+"."+fieldName(u, i), field.Type()),
Op: token.EQL,
Y: c.newIdent(y+"."+fieldName(u, i), field.Type()),
}).String())
}
if len(conds) == 0 {
conds = []string{"true"}
}
return c.formatExpr("(%s = %e, %s = %e, %s)", x, e.X, y, e.Y, strings.Join(conds, " && "))
case *types.Interface:
if isJsObject(t) {
return c.formatExpr("%s === %s", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
}
return c.formatExpr("go$interfaceIsEqual(%s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
case *types.Array:
return c.formatExpr("go$arrayIsEqual(%e, %e)", e.X, e.Y)
case *types.Pointer:
xUnary, xIsUnary := e.X.(*ast.UnaryExpr)
yUnary, yIsUnary := e.Y.(*ast.UnaryExpr)
if xIsUnary && xUnary.Op == token.AND && yIsUnary && yUnary.Op == token.AND {
xIndex, xIsIndex := xUnary.X.(*ast.IndexExpr)
yIndex, yIsIndex := yUnary.X.(*ast.IndexExpr)
if xIsIndex && yIsIndex {
return c.formatExpr("go$sliceIsEqual(%e, %f, %e, %f)", xIndex.X, xIndex.Index, yIndex.X, yIndex.Index)
}
}
switch u.Elem().Underlying().(type) {
case *types.Struct, *types.Interface:
return c.formatExpr("%s === %s", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
case *types.Array:
return c.formatExpr("go$arrayIsEqual(%s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
default:
return c.formatExpr("go$pointerIsEqual(%s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
}
default:
return c.formatExpr("%s === %s", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
}
default:
panic(e.Op)
}
case *ast.ParenExpr:
x := c.translateExpr(e.X)
if x.String() == "true" || x.String() == "false" {
return x
}
return c.formatParenExpr("%s", x)
case *ast.IndexExpr:
switch t := c.p.info.Types[e.X].Type.Underlying().(type) {
case *types.Array, *types.Pointer:
return c.formatExpr("%e[%f]", e.X, e.Index)
case *types.Slice:
return c.formatExpr(`((%2f < 0 || %2f >= %1e.length) ? go$throwRuntimeError("index out of range") : %1e.array[%1e.offset + %2f])`, e.X, e.Index)
case *types.Map:
key := c.makeKey(e.Index, t.Key())
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr(`(%1s = %2e[%3s], %1s !== undefined ? [%1s.v, true] : [%4s, false])`, c.newVariable("_entry"), e.X, key, c.zeroValue(t.Elem()))
}
return c.formatExpr(`(%1s = %2e[%3s], %1s !== undefined ? %1s.v : %4s)`, c.newVariable("_entry"), e.X, key, c.zeroValue(t.Elem()))
case *types.Basic:
return c.formatExpr("%e.charCodeAt(%f)", e.X, e.Index)
default:
panic(fmt.Sprintf("Unhandled IndexExpr: %T\n", t))
}
case *ast.SliceExpr:
if b, isBasic := c.p.info.Types[e.X].Type.Underlying().(*types.Basic); isBasic && b.Info()&types.IsString != 0 {
switch {
case e.Low == nil && e.High == nil:
return c.translateExpr(e.X)
case e.Low == nil:
return c.formatExpr("%e.substring(0, %f)", e.X, e.High)
case e.High == nil:
return c.formatExpr("%e.substring(%f)", e.X, e.Low)
default:
return c.formatExpr("%e.substring(%f, %f)", e.X, e.Low, e.High)
}
}
slice := c.translateConversionToSlice(e.X, exprType)
switch {
case e.Low == nil && e.High == nil:
return c.formatExpr("%s", slice)
case e.Low == nil:
if e.Max != nil {
return c.formatExpr("go$subslice(%s, 0, %f, %f)", slice, e.High, e.Max)
}
return c.formatExpr("go$subslice(%s, 0, %f)", slice, e.High)
case e.High == nil:
return c.formatExpr("go$subslice(%s, %f)", slice, e.Low)
default:
if e.Max != nil {
return c.formatExpr("go$subslice(%s, %f, %f, %f)", slice, e.Low, e.High, e.Max)
}
return c.formatExpr("go$subslice(%s, %f, %f)", slice, e.Low, e.High)
}
case *ast.SelectorExpr:
sel := c.p.info.Selections[e]
parameterName := func(v *types.Var) string {
if v.Anonymous() || v.Name() == "" {
return c.newVariable("param")
}
return c.newVariable(v.Name())
}
makeParametersList := func() []string {
params := sel.Obj().Type().(*types.Signature).Params()
names := make([]string, params.Len())
for i := 0; i < params.Len(); i++ {
names[i] = parameterName(params.At(i))
}
return names
}
switch sel.Kind() {
case types.FieldVal:
fields, jsTag := c.translateSelection(sel)
if jsTag != "" {
if _, ok := sel.Type().(*types.Signature); ok {
return c.formatExpr("go$internalize(%1e.%2s.%3s, %4s, %1e.%2s)", e.X, strings.Join(fields, "."), jsTag, c.typeName(sel.Type()))
}
return c.internalize(c.formatExpr("%e.%s.%s", e.X, strings.Join(fields, "."), jsTag), sel.Type())
}
return c.formatExpr("%e.%s", e.X, strings.Join(fields, "."))
case types.MethodVal:
if !sel.Obj().Exported() {
c.p.dependencies[sel.Obj()] = true
}
parameters := makeParametersList()
target := c.translateExpr(e.X)
if isWrapped(sel.Recv()) {
target = c.formatParenExpr("new %s(%s)", c.typeName(sel.Recv()), target)
}
recv := c.newVariable("_recv")
return c.formatExpr("(%s = %s, function(%s) { return %s.%s(%s); })", recv, target, strings.Join(parameters, ", "), recv, e.Sel.Name, strings.Join(parameters, ", "))
case types.MethodExpr:
if !sel.Obj().Exported() {
c.p.dependencies[sel.Obj()] = true
}
recv := "recv"
if isWrapped(sel.Recv()) {
recv = fmt.Sprintf("(new %s(recv))", c.typeName(sel.Recv()))
}
parameters := makeParametersList()
return c.formatExpr("(function(%s) { return %s.%s(%s); })", strings.Join(append([]string{"recv"}, parameters...), ", "), recv, sel.Obj().(*types.Func).Name(), strings.Join(parameters, ", "))
case types.PackageObj:
if isJsPackage(sel.Obj().Pkg()) {
switch sel.Obj().Name() {
case "Global":
return c.formatExpr("go$global")
case "This":
if c.flattened {
return c.formatExpr("go$this")
}
return c.formatExpr("this")
case "Arguments":
args := "arguments"
if c.flattened {
args = "go$args"
}
return c.formatExpr(`new (go$sliceType(%s.Object))(go$global.Array.prototype.slice.call(%s))`, c.p.pkgVars["github.com/gopherjs/gopherjs/js"], args)
default:
panic("Invalid js package object: " + sel.Obj().Name())
}
}
return c.formatExpr("%s", c.objectName(sel.Obj()))
}
panic("")
case *ast.CallExpr:
plainFun := e.Fun
for {
if p, isParen := plainFun.(*ast.ParenExpr); isParen {
plainFun = p.X
continue
}
break
}
var isType func(ast.Expr) bool
isType = func(expr ast.Expr) bool {
switch e := expr.(type) {
case *ast.ArrayType, *ast.ChanType, *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.StructType:
return true
case *ast.StarExpr:
return isType(e.X)
case *ast.Ident:
_, ok := c.p.info.Uses[e].(*types.TypeName)
return ok
case *ast.SelectorExpr:
_, ok := c.p.info.Uses[e.Sel].(*types.TypeName)
return ok
case *ast.ParenExpr:
return isType(e.X)
default:
return false
}
}
if isType(plainFun) {
return c.formatExpr("%s", c.translateConversion(e.Args[0], c.p.info.Types[plainFun].Type))
}
var fun *expression
switch f := plainFun.(type) {
case *ast.Ident:
if o, ok := c.p.info.Uses[f].(*types.Builtin); ok {
switch o.Name() {
case "new":
t := c.p.info.Types[e].Type.(*types.Pointer)
if c.p.pkg.Path() == "syscall" && types.Identical(t.Elem().Underlying(), types.Typ[types.Uintptr]) {
return c.formatExpr("new Uint8Array(8)")
}
switch t.Elem().Underlying().(type) {
case *types.Struct, *types.Array:
return c.formatExpr("%s", c.zeroValue(t.Elem()))
default:
return c.formatExpr("go$newDataPointer(%s, %s)", c.zeroValue(t.Elem()), c.typeName(t))
}
case "make":
switch argType := c.p.info.Types[e.Args[0]].Type.Underlying().(type) {
case *types.Slice:
t := c.typeName(c.p.info.Types[e.Args[0]].Type)
if len(e.Args) == 3 {
return c.formatExpr("%s.make(%f, %f, function() { return %s; })", t, e.Args[1], e.Args[2], c.zeroValue(argType.Elem()))
}
return c.formatExpr("%s.make(%f, 0, function() { return %s; })", t, e.Args[1], c.zeroValue(argType.Elem()))
case *types.Map:
return c.formatExpr("new Go$Map()")
case *types.Chan:
return c.formatExpr("new %s()", c.typeName(c.p.info.Types[e.Args[0]].Type))
default:
panic(fmt.Sprintf("Unhandled make type: %T\n", argType))
}
case "len":
arg := c.translateExpr(e.Args[0])
switch argType := c.p.info.Types[e.Args[0]].Type.Underlying().(type) {
case *types.Basic, *types.Slice:
return c.formatExpr("%s.length", arg)
case *types.Pointer:
return c.formatExpr("(%s, %d)", arg, argType.Elem().(*types.Array).Len())
case *types.Map:
return c.formatExpr("go$keys(%s).length", arg)
case *types.Chan:
return c.formatExpr("0")
// length of array is constant
default:
panic(fmt.Sprintf("Unhandled len type: %T\n", argType))
}
case "cap":
arg := c.translateExpr(e.Args[0])
switch argType := c.p.info.Types[e.Args[0]].Type.Underlying().(type) {
case *types.Slice:
return c.formatExpr("%s.capacity", arg)
case *types.Pointer:
return c.formatExpr("(%s, %d)", arg, argType.Elem().(*types.Array).Len())
case *types.Chan:
return c.formatExpr("0")
// capacity of array is constant
default:
panic(fmt.Sprintf("Unhandled cap type: %T\n", argType))
}
case "panic":
return c.formatExpr("throw go$panic(%s)", c.translateImplicitConversion(e.Args[0], types.NewInterface(nil, nil)))
case "append":
if len(e.Args) == 1 {
return c.translateExpr(e.Args[0])
}
if e.Ellipsis.IsValid() {
return c.formatExpr("go$appendSlice(%e, %s)", e.Args[0], c.translateConversionToSlice(e.Args[1], exprType))
}
sliceType := exprType.Underlying().(*types.Slice)
return c.formatExpr("go$append(%e, %s)", e.Args[0], strings.Join(c.translateExprSlice(e.Args[1:], sliceType.Elem()), ", "))
case "delete":
return c.formatExpr(`delete %e[%s]`, e.Args[0], c.makeKey(e.Args[1], c.p.info.Types[e.Args[0]].Type.Underlying().(*types.Map).Key()))
case "copy":
if basic, isBasic := c.p.info.Types[e.Args[1]].Type.Underlying().(*types.Basic); isBasic && basic.Info()&types.IsString != 0 {
return c.formatExpr("go$copyString(%e, %e)", e.Args[0], e.Args[1])
}
return c.formatExpr("go$copySlice(%e, %e)", e.Args[0], e.Args[1])
case "print", "println":
return c.formatExpr("console.log(%s)", strings.Join(c.translateExprSlice(e.Args, nil), ", "))
case "complex":
return c.formatExpr("new %s(%e, %e)", c.typeName(c.p.info.Types[e].Type), e.Args[0], e.Args[1])
case "real":
return c.formatExpr("%e.real", e.Args[0])
case "imag":
return c.formatExpr("%e.imag", e.Args[0])
case "recover":
return c.formatExpr("go$recover()")
case "close":
return c.formatExpr(`go$notSupported("close")`)
default:
panic(fmt.Sprintf("Unhandled builtin: %s\n", o.Name()))
}
}
fun = c.translateExpr(plainFun)
case *ast.SelectorExpr:
sel := c.p.info.Selections[f]
o := sel.Obj()
externalizeExpr := func(e ast.Expr) string {
t := c.p.info.Types[e].Type
if types.Identical(t, types.Typ[types.UntypedNil]) {
return "null"
}
return c.externalize(c.translateExpr(e).String(), t)
}
externalizeArgs := func(args []ast.Expr) string {
s := make([]string, len(args))
for i, arg := range args {
s[i] = externalizeExpr(arg)
}
return strings.Join(s, ", ")
}
switch sel.Kind() {
case types.MethodVal:
if !sel.Obj().Exported() {
c.p.dependencies[sel.Obj()] = true
}
methodName := o.Name()
if reservedKeywords[methodName] {
methodName += "$"
}
fun = c.translateExpr(f.X)
t := sel.Recv()
for _, index := range sel.Index()[:len(sel.Index())-1] {
if ptr, isPtr := t.(*types.Pointer); isPtr {
t = ptr.Elem()
}
s := t.Underlying().(*types.Struct)
fun = c.formatExpr("%s.%s", fun, fieldName(s, index))
t = s.Field(index).Type()
}
if isJsPackage(o.Pkg()) {
globalRef := func(id string) string {
if fun.String() == "go$global" && len(id) > 3 && strings.EqualFold(id[:3], "go$") {
return id
}
return fun.String() + "." + id
}
switch o.Name() {
case "Get":
if id, ok := c.identifierConstant(e.Args[0]); ok {
return c.formatExpr("%s", globalRef(id))
}
return c.formatExpr("%s[go$externalize(%e, Go$String)]", fun, e.Args[0])
case "Set":
if id, ok := c.identifierConstant(e.Args[0]); ok {
return c.formatExpr("%s = %s", globalRef(id), externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s[go$externalize(%e, Go$String)] = %s", fun, e.Args[0], externalizeExpr(e.Args[1]))
case "Delete":
return c.formatExpr("delete %s[go$externalize(%e, Go$String)]", fun, e.Args[0])
case "Length":
return c.formatExpr("go$parseInt(%s.length)", fun)
case "Index":
return c.formatExpr("%s[%e]", fun, e.Args[0])
case "SetIndex":
return c.formatExpr("%s[%e] = %s", fun, e.Args[0], externalizeExpr(e.Args[1]))
case "Call":
if id, ok := c.identifierConstant(e.Args[0]); ok {
if e.Ellipsis.IsValid() {
objVar := c.newVariable("obj")
return c.formatExpr("(%s = %s, %s.%s.apply(%s, %s))", objVar, fun, objVar, id, objVar, externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s(%s)", globalRef(id), externalizeArgs(e.Args[1:]))
}
if e.Ellipsis.IsValid() {
objVar := c.newVariable("obj")
return c.formatExpr("(%s = %s, %s[go$externalize(%e, Go$String)].apply(%s, %s))", objVar, fun, objVar, e.Args[0], objVar, externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s[go$externalize(%e, Go$String)](%s)", fun, e.Args[0], externalizeArgs(e.Args[1:]))
case "Invoke":
if e.Ellipsis.IsValid() {
return c.formatExpr("%s.apply(undefined, %s)", fun, externalizeExpr(e.Args[0]))
}
return c.formatExpr("%s(%s)", fun, externalizeArgs(e.Args))
case "New":
if e.Ellipsis.IsValid() {
return c.formatExpr("new (go$global.Function.prototype.bind.apply(%s, [undefined].concat(%s)))", fun, externalizeExpr(e.Args[0]))
}
return c.formatExpr("new (%s)(%s)", fun, externalizeArgs(e.Args))
case "Bool":
return c.internalize(fun, types.Typ[types.Bool])
case "Str":
return c.internalize(fun, types.Typ[types.String])
case "Int":
return c.internalize(fun, types.Typ[types.Int])
case "Int64":
return c.internalize(fun, types.Typ[types.Int64])
case "Uint64":
return c.internalize(fun, types.Typ[types.Uint64])
case "Float":
return c.internalize(fun, types.Typ[types.Float64])
case "Interface":
return c.internalize(fun, types.NewInterface(nil, nil))
case "Unsafe":
return fun
case "IsUndefined":
return c.formatParenExpr("%s === undefined", fun)
case "IsNull":
return c.formatParenExpr("%s === null", fun)
default:
panic("Invalid js package object: " + o.Name())
}
}
methodsRecvType := o.Type().(*types.Signature).Recv().Type()
_, pointerExpected := methodsRecvType.(*types.Pointer)
_, isPointer := t.Underlying().(*types.Pointer)
_, isStruct := t.Underlying().(*types.Struct)
_, isArray := t.Underlying().(*types.Array)
if pointerExpected && !isPointer && !isStruct && !isArray {
vVar := c.newVariable("v")
fun = c.formatExpr("(new %s(function() { return %s; }, function(%s) { %s = %s; })).%s", c.typeName(methodsRecvType), fun, vVar, fun, vVar, methodName)
break
}
if isWrapped(t) {
fun = c.formatExpr("(new %s(%s)).%s", c.typeName(t), fun, methodName)
break
}
fun = c.formatExpr("%s.%s", fun, methodName)
case types.PackageObj:
if isJsPackage(o.Pkg()) && o.Name() == "InternalObject" {
return c.translateExpr(e.Args[0])
}
fun = c.translateExpr(f)
case types.FieldVal:
fields, jsTag := c.translateSelection(sel)
if jsTag != "" {
sig := sel.Type().(*types.Signature)
return c.internalize(c.formatExpr("%e.%s.%s(%s)", f.X, strings.Join(fields, "."), jsTag, externalizeArgs(e.Args)), sig.Results().At(0).Type())
}
fun = c.formatExpr("%e.%s", f.X, strings.Join(fields, "."))
case types.MethodExpr:
fun = c.translateExpr(f)
default:
panic("")
}
default:
fun = c.translateExpr(plainFun)
}
sig := c.p.info.Types[plainFun].Type.Underlying().(*types.Signature)
if len(e.Args) == 1 {
if tuple, isTuple := c.p.info.Types[e.Args[0]].Type.(*types.Tuple); isTuple {
tupleVar := c.newVariable("_tuple")
args := make([]ast.Expr, tuple.Len())
for i := range args {
args[i] = c.newIdent(c.formatExpr("%s[%d]", tupleVar, i).String(), tuple.At(i).Type())
}
return c.formatExpr("(%s = %e, %s(%s))", tupleVar, e.Args[0], fun, strings.Join(c.translateArgs(sig, args, false), ", "))
}
}
return c.formatExpr("%s(%s)", fun, strings.Join(c.translateArgs(sig, e.Args, e.Ellipsis.IsValid()), ", "))
case *ast.StarExpr:
if c1, isCall := e.X.(*ast.CallExpr); isCall && len(c1.Args) == 1 {
if c2, isCall := c1.Args[0].(*ast.CallExpr); isCall && len(c2.Args) == 1 && types.Identical(c.p.info.Types[c2.Fun].Type, types.Typ[types.UnsafePointer]) {
if unary, isUnary := c2.Args[0].(*ast.UnaryExpr); isUnary && unary.Op == token.AND {
return c.translateExpr(unary.X) // unsafe conversion
}
}
}
switch exprType.Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
}
return c.formatExpr("%e.go$get()", e.X)
case *ast.TypeAssertExpr:
if e.Type == nil {
return c.translateExpr(e.X)
}
t := c.p.info.Types[e.Type].Type
check := "%1e !== null && " + c.typeCheck("%1e.constructor", t)
valueSuffix := ""
if _, isInterface := t.Underlying().(*types.Interface); !isInterface {
valueSuffix = ".go$val"
}
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr("("+check+" ? [%1e%2s, true] : [%3s, false])", e.X, valueSuffix, c.zeroValue(c.p.info.Types[e.Type].Type))
}
return c.formatExpr("("+check+" ? %1e%2s : go$typeAssertionFailed(%1e, %3s))", e.X, valueSuffix, c.typeName(t))
case *ast.Ident:
if e.Name == "_" {
panic("Tried to translate underscore identifier.")
}
switch o := c.p.info.Uses[e].(type) {
case *types.PkgName:
return c.formatExpr("%s", c.p.pkgVars[o.Pkg().Path()])
case *types.Var, *types.Const:
return c.formatExpr("%s", c.objectName(o))
case *types.Func:
return c.formatExpr("%s", c.objectName(o))
case *types.TypeName:
return c.formatExpr("%s", c.typeName(o.Type()))
case *types.Nil:
return c.formatExpr("%s", c.zeroValue(c.p.info.Types[e].Type))
default:
panic(fmt.Sprintf("Unhandled object: %T\n", o))
}
case *This:
this := "this"
if c.flattened {
this = "go$this"
}
if isWrapped(c.p.info.Types[e].Type) {
this += ".go$val"
}
return c.formatExpr(this)
case nil:
return c.formatExpr("")
default:
panic(fmt.Sprintf("Unhandled expression: %T\n", e))
}
}
// builtin typechecks a call to a built-in and returns the result via x.
// If the call has type errors, the returned x is marked as invalid.
//
func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
args := call.Args
// declare before goto's
var arg0 ast.Expr // first argument, if present
// check argument count
n := len(args)
msg := ""
bin := predeclaredFuncs[id]
if n < bin.nargs {
msg = "not enough"
} else if !bin.variadic && n > bin.nargs {
msg = "too many"
}
if msg != "" {
check.invalidOp(call.Pos(), msg+" arguments for %s (expected %d, found %d)", call, bin.nargs, n)
goto Error
}
// common case: evaluate first argument if present;
// if it is an expression, x has the expression value
if n > 0 {
arg0 = args[0]
switch id {
case _Make, _New, _Print, _Println, _Offsetof, _Trace:
// respective cases below do the work
default:
// argument must be an expression
check.expr(x, arg0)
if x.mode == invalid {
goto Error
}
}
}
switch id {
case _Append:
if _, ok := x.typ.Underlying().(*Slice); !ok {
check.invalidArg(x.pos(), "%s is not a typed slice", x)
goto Error
}
resultTyp := x.typ
for _, arg := range args[1:] {
check.expr(x, arg)
if x.mode == invalid {
goto Error
}
// TODO(gri) check assignability
}
x.mode = value
x.typ = resultTyp
case _Cap, _Len:
mode := invalid
var val exact.Value
switch typ := implicitArrayDeref(x.typ.Underlying()).(type) {
case *Basic:
if isString(typ) && id == _Len {
if x.mode == constant {
mode = constant
val = exact.MakeInt64(int64(len(exact.StringVal(x.val))))
} else {
mode = value
}
}
case *Array:
mode = value
// spec: "The expressions len(s) and cap(s) are constants
// if the type of s is an array or pointer to an array and
// the expression s does not contain channel receives or
// function calls; in this case s is not evaluated."
if !check.containsCallsOrReceives(arg0) {
mode = constant
val = exact.MakeInt64(typ.len)
}
case *Slice, *Chan:
mode = value
case *Map:
if id == _Len {
mode = value
}
}
if mode == invalid {
check.invalidArg(x.pos(), "%s for %s", x, bin.name)
goto Error
}
x.mode = mode
x.typ = Typ[Int]
x.val = val
case _Close:
ch, ok := x.typ.Underlying().(*Chan)
if !ok {
check.invalidArg(x.pos(), "%s is not a channel", x)
goto Error
}
if ch.dir&ast.SEND == 0 {
check.invalidArg(x.pos(), "%s must not be a receive-only channel", x)
goto Error
}
x.mode = novalue
case _Complex:
if !check.complexArg(x) {
goto Error
}
var y operand
check.expr(&y, args[1])
if y.mode == invalid {
goto Error
}
if !check.complexArg(&y) {
goto Error
}
check.convertUntyped(x, y.typ)
if x.mode == invalid {
goto Error
}
check.convertUntyped(&y, x.typ)
if y.mode == invalid {
goto Error
}
if !IsIdentical(x.typ, y.typ) {
check.invalidArg(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
goto Error
}
typ := x.typ.Underlying().(*Basic)
if x.mode == constant && y.mode == constant {
x.val = exact.BinaryOp(x.val, token.ADD, exact.MakeImag(y.val))
} else {
x.mode = value
}
switch typ.kind {
case Float32:
x.typ = Typ[Complex64]
case Float64:
x.typ = Typ[Complex128]
case UntypedInt, UntypedRune, UntypedFloat:
if x.mode == constant {
typ = defaultType(typ).(*Basic)
x.typ = Typ[UntypedComplex]
} else {
// untyped but not constant; probably because one
// operand is a non-constant shift of untyped lhs
typ = Typ[Float64]
x.typ = Typ[Complex128]
}
default:
check.invalidArg(x.pos(), "float32 or float64 arguments expected")
goto Error
}
if x.mode != constant {
// The arguments have now their final types, which at run-
// time will be materialized. Update the expression trees.
// If the current types are untyped, the materialized type
// is the respective default type.
// (If the result is constant, the arguments are never
// materialized and there is nothing to do.)
check.updateExprType(args[0], typ, true)
check.updateExprType(args[1], typ, true)
}
case _Copy:
var y operand
check.expr(&y, args[1])
if y.mode == invalid {
goto Error
}
var dst, src Type
if t, ok := x.typ.Underlying().(*Slice); ok {
dst = t.elt
}
switch t := y.typ.Underlying().(type) {
case *Basic:
if isString(y.typ) {
src = Typ[Byte]
}
case *Slice:
src = t.elt
}
if dst == nil || src == nil {
check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y)
goto Error
}
if !IsIdentical(dst, src) {
check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
goto Error
}
x.mode = value
x.typ = Typ[Int]
case _Delete:
m, ok := x.typ.Underlying().(*Map)
if !ok {
check.invalidArg(x.pos(), "%s is not a map", x)
goto Error
}
check.expr(x, args[1])
if x.mode == invalid {
goto Error
}
if !x.isAssignableTo(check.conf, m.key) {
check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.key)
goto Error
}
x.mode = novalue
case _Imag, _Real:
if !isComplex(x.typ) {
check.invalidArg(x.pos(), "%s must be a complex number", x)
goto Error
}
if x.mode == constant {
if id == _Real {
x.val = exact.Real(x.val)
} else {
x.val = exact.Imag(x.val)
}
} else {
x.mode = value
}
k := Invalid
switch x.typ.Underlying().(*Basic).kind {
case Complex64:
k = Float32
case Complex128:
k = Float64
case UntypedComplex:
k = UntypedFloat
default:
unreachable()
}
x.typ = Typ[k]
case _Make:
resultTyp := check.typ(arg0, nil, false)
if resultTyp == Typ[Invalid] {
goto Error
}
var min int // minimum number of arguments
switch resultTyp.Underlying().(type) {
case *Slice:
min = 2
case *Map, *Chan:
min = 1
default:
check.invalidArg(arg0.Pos(), "cannot make %s; type must be slice, map, or channel", arg0)
goto Error
}
if n := len(args); n < min || min+1 < n {
check.errorf(call.Pos(), "%s expects %d or %d arguments; found %d", call, min, min+1, n)
goto Error
}
var sizes []int64 // constant integer arguments, if any
for _, arg := range args[1:] {
if s, ok := check.index(arg, -1); ok && s >= 0 {
sizes = append(sizes, s)
}
}
if len(sizes) == 2 && sizes[0] > sizes[1] {
check.invalidArg(args[1].Pos(), "length and capacity swapped")
// safe to continue
}
x.mode = variable
x.typ = resultTyp
case _New:
resultTyp := check.typ(arg0, nil, false)
if resultTyp == Typ[Invalid] {
goto Error
}
x.mode = variable
x.typ = &Pointer{base: resultTyp}
case _Panic:
x.mode = novalue
case _Print, _Println:
for _, arg := range args {
check.expr(x, arg)
if x.mode == invalid {
goto Error
}
}
x.mode = novalue
case _Recover:
x.mode = value
x.typ = new(Interface)
case _Alignof:
x.mode = constant
x.val = exact.MakeInt64(check.conf.alignof(x.typ))
x.typ = Typ[Uintptr]
case _Offsetof:
arg, ok := unparen(arg0).(*ast.SelectorExpr)
if !ok {
check.invalidArg(arg0.Pos(), "%s is not a selector expression", arg0)
goto Error
}
check.expr(x, arg.X)
if x.mode == invalid {
goto Error
}
base := derefStructPtr(x.typ)
sel := arg.Sel.Name
obj, index, indirect := LookupFieldOrMethod(base, check.pkg, arg.Sel.Name)
switch obj.(type) {
case nil:
check.invalidArg(x.pos(), "%s has no single field %s", base, sel)
goto Error
case *Func:
check.invalidArg(arg0.Pos(), "%s is a method value", arg0)
goto Error
}
if indirect {
check.invalidArg(x.pos(), "field %s is embedded via a pointer in %s", sel, base)
goto Error
}
// TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)?
check.recordSelection(arg, FieldVal, base, obj, index, false)
offs := check.conf.offsetof(base, index)
x.mode = constant
x.val = exact.MakeInt64(offs)
x.typ = Typ[Uintptr]
case _Sizeof:
x.mode = constant
x.val = exact.MakeInt64(check.conf.sizeof(x.typ))
x.typ = Typ[Uintptr]
case _Assert:
// assert(pred) causes a typechecker error if pred is false.
// The result of assert is the value of pred if there is no error.
// Note: assert is only available in self-test mode.
if x.mode != constant || !isBoolean(x.typ) {
check.invalidArg(x.pos(), "%s is not a boolean constant", x)
goto Error
}
if x.val.Kind() != exact.Bool {
check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x)
goto Error
}
if !exact.BoolVal(x.val) {
check.errorf(call.Pos(), "%s failed", call)
// compile-time assertion failure - safe to continue
}
case _Trace:
// trace(x, y, z, ...) dumps the positions, expressions, and
// values of its arguments. The result of trace is the value
// of the first argument.
// Note: trace is only available in self-test mode.
if len(args) == 0 {
check.dump("%s: trace() without arguments", call.Pos())
x.mode = novalue
x.expr = call
return
}
var t operand
x1 := x
for _, arg := range args {
check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
check.dump("%s: %s", x1.pos(), x1)
x1 = &t // use incoming x only for first argument
}
default:
unreachable()
}
x.expr = call
return
Error:
x.mode = invalid
x.expr = call
}
func (c *funcContext) translateExpr(expr ast.Expr) *expression {
exprType := c.p.info.Types[expr].Type
if value := c.p.info.Types[expr].Value; value != nil {
basic := types.Typ[types.String]
if value.Kind() != exact.String { // workaround for bug in go/types
basic = exprType.Underlying().(*types.Basic)
}
switch {
case basic.Info()&types.IsBoolean != 0:
return c.formatExpr("%s", strconv.FormatBool(exact.BoolVal(value)))
case basic.Info()&types.IsInteger != 0:
if is64Bit(basic) {
d, _ := exact.Uint64Val(value)
if basic.Kind() == types.Int64 {
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatInt(int64(d)>>32, 10), strconv.FormatUint(d&(1<<32-1), 10))
}
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatUint(d>>32, 10), strconv.FormatUint(d&(1<<32-1), 10))
}
d, _ := exact.Int64Val(value)
return c.formatExpr("%s", strconv.FormatInt(d, 10))
case basic.Info()&types.IsFloat != 0:
f, _ := exact.Float64Val(value)
return c.formatExpr("%s", strconv.FormatFloat(f, 'g', -1, 64))
case basic.Info()&types.IsComplex != 0:
r, _ := exact.Float64Val(exact.Real(value))
i, _ := exact.Float64Val(exact.Imag(value))
if basic.Kind() == types.UntypedComplex {
exprType = types.Typ[types.Complex128]
}
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatFloat(r, 'g', -1, 64), strconv.FormatFloat(i, 'g', -1, 64))
case basic.Info()&types.IsString != 0:
return c.formatExpr("%s", encodeString(exact.StringVal(value)))
default:
panic("Unhandled constant type: " + basic.String())
}
}
switch e := expr.(type) {
case *ast.CompositeLit:
if ptrType, isPointer := exprType.(*types.Pointer); isPointer {
exprType = ptrType.Elem()
}
collectIndexedElements := func(elementType types.Type) []string {
elements := make([]string, 0)
i := 0
zero := c.zeroValue(elementType)
for _, element := range e.Elts {
if kve, isKve := element.(*ast.KeyValueExpr); isKve {
key, _ := exact.Int64Val(c.p.info.Types[kve.Key].Value)
i = int(key)
element = kve.Value
}
for len(elements) <= i {
elements = append(elements, zero)
}
elements[i] = c.translateImplicitConversionWithCloning(element, elementType).String()
i++
}
return elements
}
switch t := exprType.Underlying().(type) {
case *types.Array:
elements := collectIndexedElements(t.Elem())
if len(elements) == 0 {
return c.formatExpr("%s", c.zeroValue(t))
}
zero := c.zeroValue(t.Elem())
for len(elements) < int(t.Len()) {
elements = append(elements, zero)
}
return c.formatExpr(`$toNativeArray("%s", [%s])`, typeKind(t.Elem()), strings.Join(elements, ", "))
case *types.Slice:
return c.formatExpr("new %s([%s])", c.typeName(exprType), strings.Join(collectIndexedElements(t.Elem()), ", "))
case *types.Map:
mapVar := c.newVariable("_map")
keyVar := c.newVariable("_key")
assignments := ""
for _, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
assignments += c.formatExpr(`%s = %s, %s[%s] = { k: %s, v: %s }, `, keyVar, c.translateImplicitConversion(kve.Key, t.Key()), mapVar, c.makeKey(c.newIdent(keyVar, t.Key()), t.Key()), keyVar, c.translateImplicitConversion(kve.Value, t.Elem())).String()
}
return c.formatExpr("(%s = new $Map(), %s%s)", mapVar, assignments, mapVar)
case *types.Struct:
elements := make([]string, t.NumFields())
isKeyValue := true
if len(e.Elts) != 0 {
_, isKeyValue = e.Elts[0].(*ast.KeyValueExpr)
}
if !isKeyValue {
for i, element := range e.Elts {
elements[i] = c.translateImplicitConversion(element, t.Field(i).Type()).String()
}
}
if isKeyValue {
for i := range elements {
elements[i] = c.zeroValue(t.Field(i).Type())
}
for _, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
for j := range elements {
if kve.Key.(*ast.Ident).Name == t.Field(j).Name() {
elements[j] = c.translateImplicitConversion(kve.Value, t.Field(j).Type()).String()
break
}
}
}
}
return c.formatExpr("new %s.Ptr(%s)", c.typeName(exprType), strings.Join(elements, ", "))
default:
panic(fmt.Sprintf("Unhandled CompositeLit type: %T\n", t))
}
case *ast.FuncLit:
innerContext := c.p.analyzeFunction(exprType.(*types.Signature), e.Body)
params, body := innerContext.translateFunction(e.Type, e.Body.List, c.allVars)
if len(c.p.escapingVars) != 0 {
names := make([]string, 0, len(c.p.escapingVars))
for obj := range c.p.escapingVars {
names = append(names, c.p.objectVars[obj])
}
list := strings.Join(names, ", ")
return c.formatExpr("(function(%s) { return function(%s) {\n%s%s}; })(%s)", list, strings.Join(params, ", "), string(body), strings.Repeat("\t", c.p.indentation), list)
}
return c.formatExpr("(function(%s) {\n%s%s})", strings.Join(params, ", "), string(body), strings.Repeat("\t", c.p.indentation))
case *ast.UnaryExpr:
t := c.p.info.Types[e.X].Type
switch e.Op {
case token.AND:
switch t.Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
}
switch x := removeParens(e.X).(type) {
case *ast.CompositeLit:
return c.formatExpr("$newDataPointer(%e, %s)", x, c.typeName(c.p.info.Types[e].Type))
case *ast.Ident:
if obj := c.p.info.Uses[x]; c.p.escapingVars[obj] {
return c.formatExpr("new %s(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, %s)", c.typeName(exprType), c.p.objectVars[obj])
}
return c.formatExpr("new %s(function() { return %e; }, function($v) { %s })", c.typeName(exprType), x, c.translateAssign(x, "$v", exprType, false))
case *ast.SelectorExpr:
newSel := &ast.SelectorExpr{X: c.newIdent("this.$target", c.p.info.Types[x.X].Type), Sel: x.Sel}
c.p.info.Selections[newSel] = c.p.info.Selections[x]
return c.formatExpr("new %s(function() { return %e; }, function($v) { %s }, %e)", c.typeName(exprType), newSel, c.translateAssign(newSel, "$v", exprType, false), x.X)
case *ast.IndexExpr:
newIndex := &ast.IndexExpr{X: c.newIdent("this.$target", c.p.info.Types[x.X].Type), Index: x.Index}
return c.formatExpr("new %s(function() { return %e; }, function($v) { %s }, %e)", c.typeName(exprType), newIndex, c.translateAssign(newIndex, "$v", exprType, false), x.X)
default:
panic(fmt.Sprintf("Unhandled: %T\n", x))
}
case token.ARROW:
call := &ast.CallExpr{
Fun: c.newIdent("$recv", types.NewSignature(nil, nil, types.NewTuple(types.NewVar(0, nil, "", t)), types.NewTuple(types.NewVar(0, nil, "", exprType), types.NewVar(0, nil, "", types.Typ[types.Bool])), false)),
Args: []ast.Expr{e.X},
}
c.blocking[call] = true
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr("%e", call)
}
return c.formatExpr("%e[0]", call)
}
basic := t.Underlying().(*types.Basic)
switch e.Op {
case token.ADD:
return c.translateExpr(e.X)
case token.SUB:
switch {
case is64Bit(basic):
return c.formatExpr("new %1s(-%2h, -%2l)", c.typeName(t), e.X)
case basic.Info()&types.IsComplex != 0:
return c.formatExpr("new %1s(-%2r, -%2i)", c.typeName(t), e.X)
case basic.Info()&types.IsUnsigned != 0:
return c.fixNumber(c.formatExpr("-%e", e.X), basic)
default:
return c.formatExpr("-%e", e.X)
}
case token.XOR:
if is64Bit(basic) {
return c.formatExpr("new %1s(~%2h, ~%2l >>> 0)", c.typeName(t), e.X)
}
return c.fixNumber(c.formatExpr("~%e", e.X), basic)
case token.NOT:
x := c.translateExpr(e.X)
if x.String() == "true" {
return c.formatExpr("false")
}
if x.String() == "false" {
return c.formatExpr("true")
}
return c.formatExpr("!%s", x)
default:
panic(e.Op)
}
case *ast.BinaryExpr:
if e.Op == token.NEQ {
return c.formatExpr("!(%s)", c.translateExpr(&ast.BinaryExpr{
X: e.X,
Op: token.EQL,
Y: e.Y,
}))
}
t := c.p.info.Types[e.X].Type
t2 := c.p.info.Types[e.Y].Type
_, isInterface := t2.Underlying().(*types.Interface)
if isInterface {
t = t2
}
if basic, isBasic := t.Underlying().(*types.Basic); isBasic && basic.Info()&types.IsNumeric != 0 {
if is64Bit(basic) {
switch e.Op {
case token.MUL:
return c.formatExpr("$mul64(%e, %e)", e.X, e.Y)
case token.QUO:
return c.formatExpr("$div64(%e, %e, false)", e.X, e.Y)
case token.REM:
return c.formatExpr("$div64(%e, %e, true)", e.X, e.Y)
case token.SHL:
return c.formatExpr("$shiftLeft64(%e, %f)", e.X, e.Y)
case token.SHR:
return c.formatExpr("$shiftRight%s(%e, %f)", toJavaScriptType(basic), e.X, e.Y)
case token.EQL:
return c.formatExpr("(%1h === %2h && %1l === %2l)", e.X, e.Y)
case token.LSS:
return c.formatExpr("(%1h < %2h || (%1h === %2h && %1l < %2l))", e.X, e.Y)
case token.LEQ:
return c.formatExpr("(%1h < %2h || (%1h === %2h && %1l <= %2l))", e.X, e.Y)
case token.GTR:
return c.formatExpr("(%1h > %2h || (%1h === %2h && %1l > %2l))", e.X, e.Y)
case token.GEQ:
return c.formatExpr("(%1h > %2h || (%1h === %2h && %1l >= %2l))", e.X, e.Y)
case token.ADD, token.SUB:
return c.formatExpr("new %3s(%1h %4t %2h, %1l %4t %2l)", e.X, e.Y, c.typeName(t), e.Op)
case token.AND, token.OR, token.XOR:
return c.formatExpr("new %3s(%1h %4t %2h, (%1l %4t %2l) >>> 0)", e.X, e.Y, c.typeName(t), e.Op)
case token.AND_NOT:
return c.formatExpr("new %3s(%1h &~ %2h, (%1l &~ %2l) >>> 0)", e.X, e.Y, c.typeName(t))
default:
panic(e.Op)
}
}
if basic.Info()&types.IsComplex != 0 {
switch e.Op {
case token.EQL:
if basic.Kind() == types.Complex64 {
return c.formatExpr("($float32IsEqual(%1r, %2r) && $float32IsEqual(%1i, %2i))", e.X, e.Y)
}
return c.formatExpr("(%1r === %2r && %1i === %2i)", e.X, e.Y)
case token.ADD, token.SUB:
return c.formatExpr("new %3s(%1r %4t %2r, %1i %4t %2i)", e.X, e.Y, c.typeName(t), e.Op)
case token.MUL:
return c.formatExpr("new %3s(%1r * %2r - %1i * %2i, %1r * %2i + %1i * %2r)", e.X, e.Y, c.typeName(t))
case token.QUO:
return c.formatExpr("$divComplex(%e, %e)", e.X, e.Y)
default:
panic(e.Op)
}
}
switch e.Op {
case token.EQL:
if basic.Kind() == types.Float32 {
return c.formatParenExpr("$float32IsEqual(%e, %e)", e.X, e.Y)
}
return c.formatParenExpr("%e === %e", e.X, e.Y)
case token.LSS, token.LEQ, token.GTR, token.GEQ:
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.ADD, token.SUB:
if basic.Info()&types.IsInteger != 0 {
return c.fixNumber(c.formatExpr("%e %t %e", e.X, e.Op, e.Y), basic)
}
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.MUL:
switch basic.Kind() {
case types.Int32, types.Int:
return c.formatParenExpr("(((%1e >>> 16 << 16) * %2e >> 0) + (%1e << 16 >>> 16) * %2e) >> 0", e.X, e.Y)
case types.Uint32, types.Uint, types.Uintptr:
return c.formatParenExpr("(((%1e >>> 16 << 16) * %2e >>> 0) + (%1e << 16 >>> 16) * %2e) >>> 0", e.X, e.Y)
case types.Float32, types.Float64:
return c.formatExpr("%e * %e", e.X, e.Y)
default:
return c.fixNumber(c.formatExpr("%e * %e", e.X, e.Y), basic)
}
case token.QUO:
if basic.Info()&types.IsInteger != 0 {
// cut off decimals
shift := ">>"
if basic.Info()&types.IsUnsigned != 0 {
shift = ">>>"
}
return c.formatExpr(`(%1s = %2e / %3e, (%1s === %1s && %1s !== 1/0 && %1s !== -1/0) ? %1s %4s 0 : $throwRuntimeError("integer divide by zero"))`, c.newVariable("_q"), e.X, e.Y, shift)
}
return c.formatExpr("%e / %e", e.X, e.Y)
case token.REM:
return c.formatExpr(`(%1s = %2e %% %3e, %1s === %1s ? %1s : $throwRuntimeError("integer divide by zero"))`, c.newVariable("_r"), e.X, e.Y)
case token.SHL, token.SHR:
op := e.Op.String()
if e.Op == token.SHR && basic.Info()&types.IsUnsigned != 0 {
op = ">>>"
}
if c.p.info.Types[e.Y].Value != nil {
return c.fixNumber(c.formatExpr("%e %s %e", e.X, op, e.Y), basic)
}
if e.Op == token.SHR && basic.Info()&types.IsUnsigned == 0 {
return c.fixNumber(c.formatParenExpr("%e >> $min(%e, 31)", e.X, e.Y), basic)
}
y := c.newVariable("y")
return c.fixNumber(c.formatExpr("(%s = %s, %s < 32 ? (%e %s %s) : 0)", y, c.translateImplicitConversion(e.Y, types.Typ[types.Uint]), y, e.X, op, y), basic)
case token.AND, token.OR:
if basic.Info()&types.IsUnsigned != 0 {
return c.formatParenExpr("(%e %t %e) >>> 0", e.X, e.Op, e.Y)
}
return c.formatParenExpr("%e %t %e", e.X, e.Op, e.Y)
case token.AND_NOT:
return c.formatParenExpr("%e & ~%e", e.X, e.Y)
case token.XOR:
return c.fixNumber(c.formatParenExpr("%e ^ %e", e.X, e.Y), basic)
default:
panic(e.Op)
}
}
switch e.Op {
case token.ADD, token.LSS, token.LEQ, token.GTR, token.GEQ:
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.LAND:
x := c.translateExpr(e.X)
y := c.translateExpr(e.Y)
if x.String() == "false" {
return c.formatExpr("false")
}
return c.formatExpr("%s && %s", x, y)
case token.LOR:
x := c.translateExpr(e.X)
y := c.translateExpr(e.Y)
if x.String() == "true" {
return c.formatExpr("true")
}
return c.formatExpr("%s || %s", x, y)
case token.EQL:
switch u := t.Underlying().(type) {
case *types.Array, *types.Struct:
return c.formatExpr("$equal(%e, %e, %s)", e.X, e.Y, c.typeName(t))
case *types.Interface:
if isJsObject(t) {
return c.formatExpr("%s === %s", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
}
return c.formatExpr("$interfaceIsEqual(%s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
case *types.Pointer:
xUnary, xIsUnary := e.X.(*ast.UnaryExpr)
yUnary, yIsUnary := e.Y.(*ast.UnaryExpr)
if xIsUnary && xUnary.Op == token.AND && yIsUnary && yUnary.Op == token.AND {
xIndex, xIsIndex := xUnary.X.(*ast.IndexExpr)
yIndex, yIsIndex := yUnary.X.(*ast.IndexExpr)
if xIsIndex && yIsIndex {
return c.formatExpr("$sliceIsEqual(%e, %f, %e, %f)", xIndex.X, xIndex.Index, yIndex.X, yIndex.Index)
}
}
switch u.Elem().Underlying().(type) {
case *types.Struct, *types.Interface:
return c.formatExpr("%s === %s", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
case *types.Array:
return c.formatExpr("$equal(%s, %s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t), c.typeName(u.Elem()))
default:
return c.formatExpr("$pointerIsEqual(%s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
}
default:
return c.formatExpr("%s === %s", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
}
default:
panic(e.Op)
}
case *ast.ParenExpr:
x := c.translateExpr(e.X)
if x.String() == "true" || x.String() == "false" {
return x
}
return c.formatParenExpr("%s", x)
case *ast.IndexExpr:
switch t := c.p.info.Types[e.X].Type.Underlying().(type) {
case *types.Array, *types.Pointer:
if c.p.info.Types[e.Index].Value != nil {
return c.formatExpr("%e[%f]", e.X, e.Index)
}
return c.formatExpr(`((%2f < 0 || %2f >= %1e.length) ? $throwRuntimeError("index out of range") : %1e[%2f])`, e.X, e.Index)
case *types.Slice:
return c.formatExpr(`((%2f < 0 || %2f >= %1e.$length) ? $throwRuntimeError("index out of range") : %1e.$array[%1e.$offset + %2f])`, e.X, e.Index)
case *types.Map:
key := c.makeKey(e.Index, t.Key())
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr(`(%1s = %2e[%3s], %1s !== undefined ? [%1s.v, true] : [%4s, false])`, c.newVariable("_entry"), e.X, key, c.zeroValue(t.Elem()))
}
return c.formatExpr(`(%1s = %2e[%3s], %1s !== undefined ? %1s.v : %4s)`, c.newVariable("_entry"), e.X, key, c.zeroValue(t.Elem()))
case *types.Basic:
return c.formatExpr("%e.charCodeAt(%f)", e.X, e.Index)
default:
panic(fmt.Sprintf("Unhandled IndexExpr: %T\n", t))
}
case *ast.SliceExpr:
if b, isBasic := c.p.info.Types[e.X].Type.Underlying().(*types.Basic); isBasic && b.Info()&types.IsString != 0 {
switch {
case e.Low == nil && e.High == nil:
return c.translateExpr(e.X)
case e.Low == nil:
return c.formatExpr("%e.substring(0, %f)", e.X, e.High)
case e.High == nil:
return c.formatExpr("%e.substring(%f)", e.X, e.Low)
default:
return c.formatExpr("%e.substring(%f, %f)", e.X, e.Low, e.High)
}
}
slice := c.translateConversionToSlice(e.X, exprType)
switch {
case e.Low == nil && e.High == nil:
return c.formatExpr("%s", slice)
case e.Low == nil:
if e.Max != nil {
return c.formatExpr("$subslice(%s, 0, %f, %f)", slice, e.High, e.Max)
}
return c.formatExpr("$subslice(%s, 0, %f)", slice, e.High)
case e.High == nil:
return c.formatExpr("$subslice(%s, %f)", slice, e.Low)
default:
if e.Max != nil {
return c.formatExpr("$subslice(%s, %f, %f, %f)", slice, e.Low, e.High, e.Max)
}
return c.formatExpr("$subslice(%s, %f, %f)", slice, e.Low, e.High)
}
case *ast.SelectorExpr:
sel, ok := c.p.info.Selections[e]
if !ok {
// qualified identifier
obj := c.p.info.Uses[e.Sel]
if isJsPackage(obj.Pkg()) {
switch obj.Name() {
case "Global":
return c.formatExpr("$global")
case "This":
if len(c.flattened) != 0 {
return c.formatExpr("$this")
}
return c.formatExpr("this")
case "Arguments":
args := "arguments"
if len(c.flattened) != 0 {
args = "$args"
}
return c.formatExpr(`new ($sliceType(%s.Object))($global.Array.prototype.slice.call(%s, []))`, c.p.pkgVars["github.com/gopherjs/gopherjs/js"], args)
case "Module":
return c.formatExpr("$module")
default:
panic("Invalid js package object: " + obj.Name())
}
}
return c.formatExpr("%s", c.objectName(obj))
}
parameterName := func(v *types.Var) string {
if v.Anonymous() || v.Name() == "" {
return c.newVariable("param")
}
return c.newVariable(v.Name())
}
makeParametersList := func() []string {
params := sel.Obj().Type().(*types.Signature).Params()
names := make([]string, params.Len())
for i := 0; i < params.Len(); i++ {
names[i] = parameterName(params.At(i))
}
return names
}
switch sel.Kind() {
case types.FieldVal:
fields, jsTag := c.translateSelection(sel)
if jsTag != "" {
if _, ok := sel.Type().(*types.Signature); ok {
return c.formatExpr("$internalize(%1e.%2s.%3s, %4s, %1e.%2s)", e.X, strings.Join(fields, "."), jsTag, c.typeName(sel.Type()))
}
return c.internalize(c.formatExpr("%e.%s.%s", e.X, strings.Join(fields, "."), jsTag), sel.Type())
}
return c.formatExpr("%e.%s", e.X, strings.Join(fields, "."))
case types.MethodVal:
if !sel.Obj().Exported() {
c.p.dependencies[sel.Obj()] = true
}
parameters := makeParametersList()
target := c.translateExpr(e.X)
if isWrapped(sel.Recv()) {
target = c.formatParenExpr("new %s(%s)", c.typeName(sel.Recv()), target)
}
recv := c.newVariable("_recv")
return c.formatExpr("(%s = %s, function(%s) { $stackDepthOffset--; try { return %s.%s(%s); } finally { $stackDepthOffset++; } })", recv, target, strings.Join(parameters, ", "), recv, e.Sel.Name, strings.Join(parameters, ", "))
case types.MethodExpr:
if !sel.Obj().Exported() {
c.p.dependencies[sel.Obj()] = true
}
recv := "recv"
if isWrapped(sel.Recv()) {
recv = fmt.Sprintf("(new %s(recv))", c.typeName(sel.Recv()))
}
parameters := makeParametersList()
return c.formatExpr("(function(%s) { $stackDepthOffset--; try { return %s.%s(%s); } finally { $stackDepthOffset++; } })", strings.Join(append([]string{"recv"}, parameters...), ", "), recv, sel.Obj().(*types.Func).Name(), strings.Join(parameters, ", "))
}
panic("")
case *ast.CallExpr:
plainFun := e.Fun
for {
if p, isParen := plainFun.(*ast.ParenExpr); isParen {
plainFun = p.X
continue
}
break
}
var isType func(ast.Expr) bool
isType = func(expr ast.Expr) bool {
switch e := expr.(type) {
case *ast.ArrayType, *ast.ChanType, *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.StructType:
return true
case *ast.StarExpr:
return isType(e.X)
case *ast.Ident:
_, ok := c.p.info.Uses[e].(*types.TypeName)
return ok
case *ast.SelectorExpr:
_, ok := c.p.info.Uses[e.Sel].(*types.TypeName)
return ok
case *ast.ParenExpr:
return isType(e.X)
default:
return false
}
}
if isType(plainFun) {
return c.formatExpr("%s", c.translateConversion(e.Args[0], c.p.info.Types[plainFun].Type))
}
var fun *expression
switch f := plainFun.(type) {
case *ast.Ident:
if o, ok := c.p.info.Uses[f].(*types.Builtin); ok {
return c.translateBuiltin(o.Name(), e.Args, e.Ellipsis.IsValid(), exprType)
}
fun = c.translateExpr(plainFun)
case *ast.SelectorExpr:
sel, ok := c.p.info.Selections[f]
if !ok {
// qualified identifier
obj := c.p.info.Uses[f.Sel]
if isJsPackage(obj.Pkg()) {
switch obj.Name() {
case "InternalObject":
return c.translateExpr(e.Args[0])
}
}
fun = c.translateExpr(f)
break
}
externalizeExpr := func(e ast.Expr) string {
t := c.p.info.Types[e].Type
if types.Identical(t, types.Typ[types.UntypedNil]) {
return "null"
}
return c.externalize(c.translateExpr(e).String(), t)
}
externalizeArgs := func(args []ast.Expr) string {
s := make([]string, len(args))
for i, arg := range args {
s[i] = externalizeExpr(arg)
}
return strings.Join(s, ", ")
}
switch sel.Kind() {
case types.MethodVal:
if !sel.Obj().Exported() {
c.p.dependencies[sel.Obj()] = true
}
methodName := sel.Obj().Name()
if reservedKeywords[methodName] {
methodName += "$"
}
recvType := sel.Recv()
_, isPointer := recvType.Underlying().(*types.Pointer)
methodsRecvType := sel.Obj().Type().(*types.Signature).Recv().Type()
_, pointerExpected := methodsRecvType.(*types.Pointer)
var recv *expression
switch {
case !isPointer && pointerExpected:
recv = c.translateExpr(c.setType(&ast.UnaryExpr{Op: token.AND, X: f.X}, methodsRecvType))
default:
recv = c.translateExpr(f.X)
}
for _, index := range sel.Index()[:len(sel.Index())-1] {
if ptr, isPtr := recvType.(*types.Pointer); isPtr {
recvType = ptr.Elem()
}
s := recvType.Underlying().(*types.Struct)
recv = c.formatExpr("%s.%s", recv, fieldName(s, index))
recvType = s.Field(index).Type()
}
if isJsPackage(sel.Obj().Pkg()) {
globalRef := func(id string) string {
if recv.String() == "$global" && id[0] == '$' {
return id
}
return recv.String() + "." + id
}
switch sel.Obj().Name() {
case "Get":
if id, ok := c.identifierConstant(e.Args[0]); ok {
return c.formatExpr("%s", globalRef(id))
}
return c.formatExpr("%s[$externalize(%e, $String)]", recv, e.Args[0])
case "Set":
if id, ok := c.identifierConstant(e.Args[0]); ok {
return c.formatExpr("%s = %s", globalRef(id), externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s[$externalize(%e, $String)] = %s", recv, e.Args[0], externalizeExpr(e.Args[1]))
case "Delete":
return c.formatExpr("delete %s[$externalize(%e, $String)]", recv, e.Args[0])
case "Length":
return c.formatExpr("$parseInt(%s.length)", recv)
case "Index":
return c.formatExpr("%s[%e]", recv, e.Args[0])
case "SetIndex":
return c.formatExpr("%s[%e] = %s", recv, e.Args[0], externalizeExpr(e.Args[1]))
case "Call":
if id, ok := c.identifierConstant(e.Args[0]); ok {
if e.Ellipsis.IsValid() {
objVar := c.newVariable("obj")
return c.formatExpr("(%s = %s, %s.%s.apply(%s, %s))", objVar, recv, objVar, id, objVar, externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s(%s)", globalRef(id), externalizeArgs(e.Args[1:]))
}
if e.Ellipsis.IsValid() {
objVar := c.newVariable("obj")
return c.formatExpr("(%s = %s, %s[$externalize(%e, $String)].apply(%s, %s))", objVar, recv, objVar, e.Args[0], objVar, externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s[$externalize(%e, $String)](%s)", recv, e.Args[0], externalizeArgs(e.Args[1:]))
case "Invoke":
if e.Ellipsis.IsValid() {
return c.formatExpr("%s.apply(undefined, %s)", recv, externalizeExpr(e.Args[0]))
}
return c.formatExpr("%s(%s)", recv, externalizeArgs(e.Args))
case "New":
if e.Ellipsis.IsValid() {
return c.formatExpr("new ($global.Function.prototype.bind.apply(%s, [undefined].concat(%s)))", recv, externalizeExpr(e.Args[0]))
}
return c.formatExpr("new (%s)(%s)", recv, externalizeArgs(e.Args))
case "Bool":
return c.internalize(recv, types.Typ[types.Bool])
case "Str":
return c.internalize(recv, types.Typ[types.String])
case "Int":
return c.internalize(recv, types.Typ[types.Int])
case "Int64":
return c.internalize(recv, types.Typ[types.Int64])
case "Uint64":
return c.internalize(recv, types.Typ[types.Uint64])
case "Float":
return c.internalize(recv, types.Typ[types.Float64])
case "Interface":
return c.internalize(recv, types.NewInterface(nil, nil))
case "Unsafe":
return recv
case "IsUndefined":
return c.formatParenExpr("%s === undefined", recv)
case "IsNull":
return c.formatParenExpr("%s === null", recv)
default:
panic("Invalid js package object: " + sel.Obj().Name())
}
}
if isWrapped(methodsRecvType) {
fun = c.formatExpr("(new %s(%s)).%s", c.typeName(methodsRecvType), recv, methodName)
break
}
fun = c.formatExpr("%s.%s", recv, methodName)
case types.FieldVal:
fields, jsTag := c.translateSelection(sel)
if jsTag != "" {
sig := sel.Type().(*types.Signature)
return c.internalize(c.formatExpr("%e.%s.%s(%s)", f.X, strings.Join(fields, "."), jsTag, externalizeArgs(e.Args)), sig.Results().At(0).Type())
}
fun = c.formatExpr("%e.%s", f.X, strings.Join(fields, "."))
case types.MethodExpr:
fun = c.translateExpr(f)
default:
panic("")
}
default:
fun = c.translateExpr(plainFun)
}
sig := c.p.info.Types[plainFun].Type.Underlying().(*types.Signature)
if len(e.Args) == 1 {
if tuple, isTuple := c.p.info.Types[e.Args[0]].Type.(*types.Tuple); isTuple {
tupleVar := c.newVariable("_tuple")
args := make([]ast.Expr, tuple.Len())
for i := range args {
args[i] = c.newIdent(c.formatExpr("%s[%d]", tupleVar, i).String(), tuple.At(i).Type())
}
return c.formatExpr("(%s = %e, %s(%s))", tupleVar, e.Args[0], fun, strings.Join(c.translateArgs(sig, args, false), ", "))
}
}
args := c.translateArgs(sig, e.Args, e.Ellipsis.IsValid())
if c.blocking[e] {
resumeCase := c.caseCounter
c.caseCounter++
returnVar := "$r"
if sig.Results().Len() != 0 {
returnVar = c.newVariable("_r")
}
c.Printf("%[1]s = %[2]s(%[3]s); /* */ $s = %[4]d; case %[4]d: if (%[1]s && %[1]s.constructor === Function) { %[1]s = %[1]s(); }", returnVar, fun, strings.Join(append(args, "true"), ", "), resumeCase)
if sig.Results().Len() != 0 {
return c.formatExpr("%s", returnVar)
}
return nil
}
return c.formatExpr("%s(%s)", fun, strings.Join(args, ", "))
case *ast.StarExpr:
if c1, isCall := e.X.(*ast.CallExpr); isCall && len(c1.Args) == 1 {
if c2, isCall := c1.Args[0].(*ast.CallExpr); isCall && len(c2.Args) == 1 && types.Identical(c.p.info.Types[c2.Fun].Type, types.Typ[types.UnsafePointer]) {
if unary, isUnary := c2.Args[0].(*ast.UnaryExpr); isUnary && unary.Op == token.AND {
return c.translateExpr(unary.X) // unsafe conversion
}
}
}
switch exprType.Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
}
return c.formatExpr("%e.$get()", e.X)
case *ast.TypeAssertExpr:
if e.Type == nil {
return c.translateExpr(e.X)
}
t := c.p.info.Types[e.Type].Type
check := "%1e !== null && " + c.typeCheck("%1e.constructor", t)
valueSuffix := ""
if _, isInterface := t.Underlying().(*types.Interface); !isInterface {
valueSuffix = ".$val"
}
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr("("+check+" ? [%1e%2s, true] : [%3s, false])", e.X, valueSuffix, c.zeroValue(c.p.info.Types[e.Type].Type))
}
return c.formatExpr("("+check+" ? %1e%2s : $typeAssertionFailed(%1e, %3s))", e.X, valueSuffix, c.typeName(t))
case *ast.Ident:
if e.Name == "_" {
panic("Tried to translate underscore identifier.")
}
obj := c.p.info.Defs[e]
if obj == nil {
obj = c.p.info.Uses[e]
}
switch o := obj.(type) {
case *types.PkgName:
return c.formatExpr("%s", c.p.pkgVars[o.Pkg().Path()])
case *types.Var, *types.Const:
return c.formatExpr("%s", c.objectName(o))
case *types.Func:
return c.formatExpr("%s", c.objectName(o))
case *types.TypeName:
return c.formatExpr("%s", c.typeName(o.Type()))
case *types.Nil:
return c.formatExpr("%s", c.zeroValue(c.p.info.Types[e].Type))
default:
panic(fmt.Sprintf("Unhandled object: %T\n", o))
}
case *This:
this := "this"
if len(c.flattened) != 0 {
this = "$this"
}
if isWrapped(c.p.info.Types[e].Type) {
this += ".$val"
}
return c.formatExpr(this)
case nil:
return c.formatExpr("")
default:
panic(fmt.Sprintf("Unhandled expression: %T\n", e))
}
}
func (c *PkgContext) translateMethod(typeName string, isStruct bool, fun *ast.FuncDecl) {
c.newScope(func() {
sig := c.info.Objects[fun.Name].(*types.Func).Type().(*types.Signature)
recvType := sig.Recv().Type()
ptr, isPointer := recvType.(*types.Pointer)
params := c.translateParams(fun.Type)
joinedParams := strings.Join(params, ", ")
printPrimaryFunction := func(lhs string) {
c.Printf("%s = function(%s) {", lhs, joinedParams)
c.Indent(func() {
if jsCode, ok := c.pkg.Scope().Lookup("js_" + typeName + "_" + fun.Name.Name).(*types.Const); ok {
c.Write([]byte(exact.StringVal(jsCode.Val())))
c.Write([]byte{'\n'})
return
}
if fun.Body == nil {
c.Printf(`throw new Go$Panic("Native function not implemented: %s.%s");`, typeName, fun.Name.Name)
return
}
body := fun.Body.List
if fun.Recv.List[0].Names != nil {
recv := fun.Recv.List[0].Names[0]
c.info.Types[recv] = recvType
this := c.newIdent("this", recvType)
if isWrapped(recvType) {
this = c.newIdent("this.Go$val", recvType)
}
body = append([]ast.Stmt{
&ast.AssignStmt{
Lhs: []ast.Expr{recv},
Tok: token.DEFINE,
Rhs: []ast.Expr{this},
},
}, body...)
}
c.translateFunctionBody(body, sig)
})
c.Printf("};")
}
switch {
case isStruct:
printPrimaryFunction(typeName + ".prototype." + fun.Name.Name)
c.Printf("%s.Go$NonPointer.prototype.%s = function(%s) { return this.Go$val.%s(%s); };", typeName, fun.Name.Name, joinedParams, fun.Name.Name, joinedParams)
case !isStruct && !isPointer:
value := "this.Go$get()"
if isWrapped(recvType) {
value = fmt.Sprintf("new %s(%s)", typeName, value)
}
printPrimaryFunction(typeName + ".prototype." + fun.Name.Name)
c.Printf("%s.Go$Pointer.prototype.%s = function(%s) { return %s.%s(%s); };", typeName, fun.Name.Name, joinedParams, value, fun.Name.Name, joinedParams)
case !isStruct && isPointer:
if _, isArray := ptr.Elem().Underlying().(*types.Array); isArray {
printPrimaryFunction(typeName + ".prototype." + fun.Name.Name)
break
}
value := "this"
if isWrapped(ptr.Elem()) {
value = "this.Go$val"
}
c.Printf("%s.prototype.%s = function(%s) { var obj = %s; return (new %s.Go$Pointer(function() { return obj; }, null)).%s(%s); };", typeName, fun.Name.Name, joinedParams, value, typeName, fun.Name.Name, joinedParams)
printPrimaryFunction(typeName + ".Go$Pointer.prototype." + fun.Name.Name)
}
})
}
// builtin type-checks a call to the built-in specified by id and
// returns true if the call is valid, with *x holding the result;
// but x.expr is not set. If the call is invalid, the result is
// false, and *x is undefined.
//
func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
// append is the only built-in that permits the use of ... for the last argument
bin := predeclaredFuncs[id]
if call.Ellipsis.IsValid() && id != _Append {
check.invalidOp(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)
check.use(call.Args...)
return
}
// For len(x) and cap(x) we need to know if x contains any function calls or
// receive operations. Save/restore current setting and set hasCallOrRecv to
// false for the evaluation of x so that we can check it afterwards.
// Note: We must do this _before_ calling unpack because unpack evaluates the
// first argument before we even call arg(x, 0)!
if id == _Len || id == _Cap {
defer func(b bool) {
check.hasCallOrRecv = b
}(check.hasCallOrRecv)
check.hasCallOrRecv = false
}
// determine actual arguments
var arg getter
nargs := len(call.Args)
switch id {
default:
// make argument getter
arg, nargs, _ = unpack(func(x *operand, i int) { check.expr(x, call.Args[i]) }, nargs, false)
// evaluate first argument, if present
if nargs > 0 {
arg(x, 0)
if x.mode == invalid {
return
}
}
case _Make, _New, _Offsetof, _Trace:
// arguments require special handling
}
// check argument count
{
msg := ""
if nargs < bin.nargs {
msg = "not enough"
} else if !bin.variadic && nargs > bin.nargs {
msg = "too many"
}
if msg != "" {
check.invalidOp(call.Rparen, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
return
}
}
switch id {
case _Append:
// append(s S, x ...T) S, where T is the element type of S
// spec: "The variadic function append appends zero or more values x to s of type
// S, which must be a slice type, and returns the resulting slice, also of type S.
// The values x are passed to a parameter of type ...T where T is the element type
// of S and the respective parameter passing rules apply."
S := x.typ
var T Type
if s, _ := S.Underlying().(*Slice); s != nil {
T = s.elem
} else {
check.invalidArg(x.pos(), "%s is not a slice", x)
return
}
// remember arguments that have been evaluated already
alist := []operand{*x}
// spec: "As a special case, append also accepts a first argument assignable
// to type []byte with a second argument of string type followed by ... .
// This form appends the bytes of the string.
if nargs == 2 && call.Ellipsis.IsValid() && x.assignableTo(check.conf, NewSlice(UniverseByte)) {
arg(x, 1)
if x.mode == invalid {
return
}
if isString(x.typ) {
if check.Types != nil {
sig := makeSig(S, S, x.typ)
sig.variadic = true
check.recordBuiltinType(call.Fun, sig)
}
x.mode = value
x.typ = S
break
}
alist = append(alist, *x)
// fallthrough
}
// check general case by creating custom signature
sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature
sig.variadic = true
check.arguments(x, call, sig, func(x *operand, i int) {
// only evaluate arguments that have not been evaluated before
if i < len(alist) {
*x = alist[i]
return
}
arg(x, i)
}, nargs)
// ok to continue even if check.arguments reported errors
x.mode = value
x.typ = S
if check.Types != nil {
check.recordBuiltinType(call.Fun, sig)
}
case _Cap, _Len:
// cap(x)
// len(x)
mode := invalid
var typ Type
var val exact.Value
switch typ = implicitArrayDeref(x.typ.Underlying()); t := typ.(type) {
case *Basic:
if isString(t) && id == _Len {
if x.mode == constant {
mode = constant
val = exact.MakeInt64(int64(len(exact.StringVal(x.val))))
} else {
mode = value
}
}
case *Array:
mode = value
// spec: "The expressions len(s) and cap(s) are constants
// if the type of s is an array or pointer to an array and
// the expression s does not contain channel receives or
// function calls; in this case s is not evaluated."
if !check.hasCallOrRecv {
mode = constant
val = exact.MakeInt64(t.len)
}
case *Slice, *Chan:
mode = value
case *Map:
if id == _Len {
mode = value
}
}
if mode == invalid {
check.invalidArg(x.pos(), "%s for %s", x, bin.name)
return
}
x.mode = mode
x.typ = Typ[Int]
x.val = val
if check.Types != nil && mode != constant {
check.recordBuiltinType(call.Fun, makeSig(x.typ, typ))
}
case _Close:
// close(c)
c, _ := x.typ.Underlying().(*Chan)
if c == nil {
check.invalidArg(x.pos(), "%s is not a channel", x)
return
}
if c.dir == RecvOnly {
check.invalidArg(x.pos(), "%s must not be a receive-only channel", x)
return
}
x.mode = novalue
if check.Types != nil {
check.recordBuiltinType(call.Fun, makeSig(nil, c))
}
case _Complex:
// complex(x, y realT) complexT
if !check.complexArg(x) {
return
}
var y operand
arg(&y, 1)
if y.mode == invalid {
return
}
if !check.complexArg(&y) {
return
}
check.convertUntyped(x, y.typ)
if x.mode == invalid {
return
}
check.convertUntyped(&y, x.typ)
if y.mode == invalid {
return
}
if !Identical(x.typ, y.typ) {
check.invalidArg(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
return
}
if x.mode == constant && y.mode == constant {
x.val = exact.BinaryOp(x.val, token.ADD, exact.MakeImag(y.val))
} else {
x.mode = value
}
realT := x.typ
complexT := Typ[Invalid]
switch realT.Underlying().(*Basic).kind {
case Float32:
complexT = Typ[Complex64]
case Float64:
complexT = Typ[Complex128]
case UntypedInt, UntypedRune, UntypedFloat:
if x.mode == constant {
realT = defaultType(realT).(*Basic)
complexT = Typ[UntypedComplex]
} else {
// untyped but not constant; probably because one
// operand is a non-constant shift of untyped lhs
realT = Typ[Float64]
complexT = Typ[Complex128]
}
default:
check.invalidArg(x.pos(), "float32 or float64 arguments expected")
return
}
x.typ = complexT
if check.Types != nil && x.mode != constant {
check.recordBuiltinType(call.Fun, makeSig(complexT, realT, realT))
}
if x.mode != constant {
// The arguments have now their final types, which at run-
// time will be materialized. Update the expression trees.
// If the current types are untyped, the materialized type
// is the respective default type.
// (If the result is constant, the arguments are never
// materialized and there is nothing to do.)
check.updateExprType(x.expr, realT, true)
check.updateExprType(y.expr, realT, true)
}
case _Copy:
// copy(x, y []T) int
var dst Type
if t, _ := x.typ.Underlying().(*Slice); t != nil {
dst = t.elem
}
var y operand
arg(&y, 1)
if y.mode == invalid {
return
}
var src Type
switch t := y.typ.Underlying().(type) {
case *Basic:
if isString(y.typ) {
src = UniverseByte
}
case *Slice:
src = t.elem
}
if dst == nil || src == nil {
check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y)
return
}
if !Identical(dst, src) {
check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
return
}
if check.Types != nil {
check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ))
}
x.mode = value
x.typ = Typ[Int]
case _Delete:
// delete(m, k)
m, _ := x.typ.Underlying().(*Map)
if m == nil {
check.invalidArg(x.pos(), "%s is not a map", x)
return
}
arg(x, 1) // k
if x.mode == invalid {
return
}
if !x.assignableTo(check.conf, m.key) {
check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.key)
return
}
x.mode = novalue
if check.Types != nil {
check.recordBuiltinType(call.Fun, makeSig(nil, m, m.key))
}
case _Imag, _Real:
// imag(complexT) realT
// real(complexT) realT
if !isComplex(x.typ) {
check.invalidArg(x.pos(), "%s must be a complex number", x)
return
}
if x.mode == constant {
if id == _Real {
x.val = exact.Real(x.val)
} else {
x.val = exact.Imag(x.val)
}
} else {
x.mode = value
}
var k BasicKind
switch x.typ.Underlying().(*Basic).kind {
case Complex64:
k = Float32
case Complex128:
k = Float64
case UntypedComplex:
k = UntypedFloat
default:
unreachable()
}
if check.Types != nil && x.mode != constant {
check.recordBuiltinType(call.Fun, makeSig(Typ[k], x.typ))
}
x.typ = Typ[k]
case _Make:
// make(T, n)
// make(T, n, m)
// (no argument evaluated yet)
arg0 := call.Args[0]
T := check.typ(arg0)
if T == Typ[Invalid] {
return
}
var min int // minimum number of arguments
switch T.Underlying().(type) {
case *Slice:
min = 2
case *Map, *Chan:
min = 1
default:
check.invalidArg(arg0.Pos(), "cannot make %s; type must be slice, map, or channel", arg0)
return
}
if nargs < min || min+1 < nargs {
check.errorf(call.Pos(), "%s expects %d or %d arguments; found %d", call, min, min+1, nargs)
return
}
var sizes []int64 // constant integer arguments, if any
for _, arg := range call.Args[1:] {
if s, ok := check.index(arg, -1); ok && s >= 0 {
sizes = append(sizes, s)
}
}
if len(sizes) == 2 && sizes[0] > sizes[1] {
check.invalidArg(call.Args[1].Pos(), "length and capacity swapped")
// safe to continue
}
x.mode = value
x.typ = T
if check.Types != nil {
params := [...]Type{T, Typ[Int], Typ[Int]}
check.recordBuiltinType(call.Fun, makeSig(x.typ, params[:1+len(sizes)]...))
}
case _New:
// new(T)
// (no argument evaluated yet)
T := check.typ(call.Args[0])
if T == Typ[Invalid] {
return
}
x.mode = value
x.typ = &Pointer{base: T}
if check.Types != nil {
check.recordBuiltinType(call.Fun, makeSig(x.typ, T))
}
case _Panic:
// panic(x)
T := new(Interface)
if !check.assignment(x, T) {
assert(x.mode == invalid)
return
}
x.mode = novalue
if check.Types != nil {
check.recordBuiltinType(call.Fun, makeSig(nil, T))
}
case _Print, _Println:
// print(x, y, ...)
// println(x, y, ...)
var params []Type
if nargs > 0 {
params = make([]Type, nargs)
for i := 0; i < nargs; i++ {
if i > 0 {
arg(x, i) // first argument already evaluated
}
if !check.assignment(x, nil) {
assert(x.mode == invalid)
return
}
params[i] = x.typ
}
}
x.mode = novalue
if check.Types != nil {
check.recordBuiltinType(call.Fun, makeSig(nil, params...))
}
case _Recover:
// recover() interface{}
x.mode = value
x.typ = new(Interface)
if check.Types != nil {
check.recordBuiltinType(call.Fun, makeSig(x.typ))
}
case _Alignof:
// unsafe.Alignof(x T) uintptr
if !check.assignment(x, nil) {
assert(x.mode == invalid)
return
}
x.mode = constant
x.val = exact.MakeInt64(check.conf.alignof(x.typ))
x.typ = Typ[Uintptr]
// result is constant - no need to record signature
case _Offsetof:
// unsafe.Offsetof(x T) uintptr, where x must be a selector
// (no argument evaluated yet)
arg0 := call.Args[0]
selx, _ := unparen(arg0).(*ast.SelectorExpr)
if selx == nil {
check.invalidArg(arg0.Pos(), "%s is not a selector expression", arg0)
check.use(arg0)
return
}
check.expr(x, selx.X)
if x.mode == invalid {
return
}
base := derefStructPtr(x.typ)
sel := selx.Sel.Name
obj, index, indirect := LookupFieldOrMethod(base, false, check.pkg, sel)
switch obj.(type) {
case nil:
check.invalidArg(x.pos(), "%s has no single field %s", base, sel)
return
case *Func:
// TODO(gri) Using derefStructPtr may result in methods being found
// that don't actually exist. An error either way, but the error
// message is confusing. See: http://play.golang.org/p/al75v23kUy ,
// but go/types reports: "invalid argument: x.m is a method value".
check.invalidArg(arg0.Pos(), "%s is a method value", arg0)
return
}
if indirect {
check.invalidArg(x.pos(), "field %s is embedded via a pointer in %s", sel, base)
return
}
// TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)?
check.recordSelection(selx, FieldVal, base, obj, index, false)
offs := check.conf.offsetof(base, index)
x.mode = constant
x.val = exact.MakeInt64(offs)
x.typ = Typ[Uintptr]
// result is constant - no need to record signature
case _Sizeof:
// unsafe.Sizeof(x T) uintptr
if !check.assignment(x, nil) {
assert(x.mode == invalid)
return
}
x.mode = constant
x.val = exact.MakeInt64(check.conf.sizeof(x.typ))
x.typ = Typ[Uintptr]
// result is constant - no need to record signature
case _Assert:
// assert(pred) causes a typechecker error if pred is false.
// The result of assert is the value of pred if there is no error.
// Note: assert is only available in self-test mode.
if x.mode != constant || !isBoolean(x.typ) {
check.invalidArg(x.pos(), "%s is not a boolean constant", x)
return
}
if x.val.Kind() != exact.Bool {
check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x)
return
}
if !exact.BoolVal(x.val) {
check.errorf(call.Pos(), "%s failed", call)
// compile-time assertion failure - safe to continue
}
// result is constant - no need to record signature
case _Trace:
// trace(x, y, z, ...) dumps the positions, expressions, and
// values of its arguments. The result of trace is the value
// of the first argument.
// Note: trace is only available in self-test mode.
// (no argument evaluated yet)
if nargs == 0 {
check.dump("%s: trace() without arguments", call.Pos())
x.mode = novalue
break
}
var t operand
x1 := x
for _, arg := range call.Args {
check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
check.dump("%s: %s", x1.pos(), x1)
x1 = &t // use incoming x only for first argument
}
// trace is only available in test mode - no need to record signature
default:
unreachable()
}
return true
}
func TranslatePackage(importPath string, files []*ast.File, fileSet *token.FileSet, config *types.Config) ([]byte, error) {
info := &types.Info{
Types: make(map[ast.Expr]types.Type),
Values: make(map[ast.Expr]exact.Value),
Objects: make(map[*ast.Ident]types.Object),
Implicits: make(map[ast.Node]types.Object),
Selections: make(map[*ast.SelectorExpr]*types.Selection),
}
var errList ErrorList
var previousErr error
config.Error = func(err error) {
if previousErr != nil && previousErr.Error() == err.Error() {
return
}
errList = append(errList, err)
previousErr = err
}
config.Sizes = sizes32
typesPkg, err := config.Check(importPath, fileSet, files, info)
if errList != nil {
return nil, errList
}
if err != nil {
return nil, err
}
config.Packages[importPath] = typesPkg
c := &PkgContext{
pkg: typesPkg,
info: info,
pkgVars: make(map[string]string),
objectVars: make(map[types.Object]string),
allVarNames: make(map[string]int),
postLoopStmt: make(map[string]ast.Stmt),
positions: make(map[int]token.Pos),
}
for _, name := range ReservedKeywords {
c.allVarNames[name] = 1
}
functionsByType := make(map[types.Type][]*ast.FuncDecl)
functionsByObject := make(map[types.Object]*ast.FuncDecl)
var initStmts []ast.Stmt
var typeSpecs []*ast.TypeSpec
var constSpecs []*ast.ValueSpec
var varSpecs []*ast.ValueSpec
for _, file := range files {
for _, decl := range file.Decls {
switch d := decl.(type) {
case *ast.FuncDecl:
sig := c.info.Objects[d.Name].(*types.Func).Type().(*types.Signature)
var recvType types.Type
if sig.Recv() != nil {
recvType = sig.Recv().Type()
if ptr, isPtr := recvType.(*types.Pointer); isPtr {
recvType = ptr.Elem()
}
}
if sig.Recv() == nil && d.Name.Name == "init" {
initStmts = append(initStmts, d.Body.List...)
continue
}
functionsByType[recvType] = append(functionsByType[recvType], d)
o := c.info.Objects[d.Name]
functionsByObject[o] = d
if sig.Recv() == nil {
c.objectName(o) // register toplevel name
}
case *ast.GenDecl:
switch d.Tok {
case token.TYPE:
for _, spec := range d.Specs {
s := spec.(*ast.TypeSpec)
typeSpecs = append(typeSpecs, s)
c.objectName(c.info.Objects[s.Name]) // register toplevel name
}
case token.CONST:
for _, spec := range d.Specs {
s := spec.(*ast.ValueSpec)
constSpecs = append(constSpecs, s)
for _, name := range s.Names {
if !isBlank(name) {
c.objectName(c.info.Objects[name]) // register toplevel name
}
}
}
case token.VAR:
for _, spec := range d.Specs {
s := spec.(*ast.ValueSpec)
varSpecs = append(varSpecs, s)
for _, name := range s.Names {
if !isBlank(name) {
c.objectName(c.info.Objects[name]) // register toplevel name
}
}
}
}
}
}
}
// resolve var dependencies
var unorderedSingleVarSpecs []*ast.ValueSpec
pendingObjects := make(map[types.Object]bool)
for _, spec := range varSpecs {
for _, singleSpec := range c.splitValueSpec(spec) {
if singleSpec.Values[0] == nil {
continue
}
unorderedSingleVarSpecs = append(unorderedSingleVarSpecs, singleSpec)
for _, name := range singleSpec.Names {
pendingObjects[c.info.Objects[name]] = true
}
}
}
complete := false
var intVarStmts []ast.Stmt
for !complete {
complete = true
for i, spec := range unorderedSingleVarSpecs {
if spec == nil {
continue
}
v := DependencyCollector{info: c.info, functions: functionsByObject}
ast.Walk(&v, spec.Values[0])
currentObjs := make(map[types.Object]bool)
for _, name := range spec.Names {
currentObjs[c.info.Objects[name]] = true
}
ready := true
for _, dep := range v.dependencies {
if currentObjs[dep] {
return nil, fmt.Errorf("%s: initialization loop", fileSet.Position(dep.Pos()).String())
}
ready = ready && !pendingObjects[dep]
}
if !ready {
complete = false
continue
}
lhs := make([]ast.Expr, len(spec.Names))
for i, name := range spec.Names {
lhs[i] = name
delete(pendingObjects, c.info.Objects[name])
}
intVarStmts = append(intVarStmts, &ast.AssignStmt{
Lhs: lhs,
Tok: token.DEFINE,
Rhs: spec.Values,
})
unorderedSingleVarSpecs[i] = nil
}
}
c.Indent(func() {
for _, importedPkg := range typesPkg.Imports() {
varName := c.newVariable(importedPkg.Name())
c.Printf(`var %s = Go$packages["%s"];`, varName, importedPkg.Path())
c.pkgVars[importedPkg.Path()] = varName
}
// types and their functions
for _, spec := range typeSpecs {
obj := c.info.Objects[spec.Name]
typeName := c.objectName(obj)
c.Printf("var %s;", typeName)
c.translateTypeSpec(spec)
for _, fun := range functionsByType[obj.Type()] {
_, isStruct := obj.Type().Underlying().(*types.Struct)
c.translateMethod(typeName, isStruct, fun)
}
c.Printf("Go$pkg.%s = %s;", typeName, typeName)
}
// package functions
for _, fun := range functionsByType[nil] {
if isBlank(fun.Name) {
continue
}
c.newScope(func() {
name := c.objectName(c.info.Objects[fun.Name])
params := c.translateParams(fun.Type)
c.Printf("var %s = function(%s) {", name, strings.Join(params, ", "))
c.Indent(func() {
jsCode, _ := typesPkg.Scope().Lookup("js_" + name).(*types.Const)
if jsCode != nil {
c.Write([]byte(exact.StringVal(jsCode.Val())))
c.Write([]byte{'\n'})
return
}
if fun.Body == nil {
c.Printf(`throw new Go$Panic("Native function not implemented: %s");`, name)
return
}
c.translateFunctionBody(fun.Body.List, c.info.Objects[fun.Name].Type().(*types.Signature))
})
c.Printf("};")
})
}
// constants
for _, spec := range constSpecs {
for _, name := range spec.Names {
if isBlank(name) || strings.HasPrefix(name.Name, "js_") {
continue
}
o := c.info.Objects[name].(*types.Const)
c.info.Types[name] = o.Type()
c.info.Values[name] = o.Val()
c.Printf("%s = %s;", c.objectName(o), c.translateExpr(name))
}
}
// variables
for _, spec := range varSpecs {
for _, name := range spec.Names {
o := c.info.Objects[name].(*types.Var)
c.Printf("%s = %s;", c.objectName(o), c.zeroValue(o.Type()))
}
}
// native implementations
if native, hasNative := natives[importPath]; hasNative {
c.Write([]byte(strings.TrimSpace(native)))
c.Write([]byte{'\n'})
}
// exports for package functions
for _, fun := range functionsByType[nil] {
name := fun.Name.Name
if fun.Name.IsExported() || name == "main" {
c.Printf("Go$pkg.%s = %s;", name, name)
}
}
// init function
c.Printf("Go$pkg.init = function() {")
c.Indent(func() {
c.translateFunctionBody(append(intVarStmts, initStmts...), nil)
})
c.Printf("};")
})
return c.output, nil
}
func (c *compiler) NewConstValue(v exact.Value, typ types.Type) *LLVMValue {
switch {
case v.Kind() == exact.Unknown:
// TODO nil literals should be represented more appropriately once the exact-package supports it.
llvmtyp := c.types.ToLLVM(typ)
return c.NewValue(llvm.ConstNull(llvmtyp), typ)
case isString(typ):
if isUntyped(typ) {
typ = types.Typ[types.String]
}
llvmtyp := c.types.ToLLVM(typ)
strval := exact.StringVal(v)
strlen := len(strval)
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
var ptr llvm.Value
if strlen > 0 {
init := llvm.ConstString(strval, false)
ptr = llvm.AddGlobal(c.module.Module, init.Type(), "")
ptr.SetInitializer(init)
ptr = llvm.ConstBitCast(ptr, i8ptr)
} else {
ptr = llvm.ConstNull(i8ptr)
}
len_ := llvm.ConstInt(c.types.inttype, uint64(strlen), false)
llvmvalue := llvm.Undef(llvmtyp)
llvmvalue = llvm.ConstInsertValue(llvmvalue, ptr, []uint32{0})
llvmvalue = llvm.ConstInsertValue(llvmvalue, len_, []uint32{1})
return c.NewValue(llvmvalue, typ)
case isInteger(typ):
if isUntyped(typ) {
typ = types.Typ[types.Int]
}
llvmtyp := c.types.ToLLVM(typ)
var llvmvalue llvm.Value
if isUnsigned(typ) {
v, _ := exact.Uint64Val(v)
llvmvalue = llvm.ConstInt(llvmtyp, v, false)
} else {
v, _ := exact.Int64Val(v)
llvmvalue = llvm.ConstInt(llvmtyp, uint64(v), true)
}
return c.NewValue(llvmvalue, typ)
case isBoolean(typ):
if isUntyped(typ) {
typ = types.Typ[types.Bool]
}
var llvmvalue llvm.Value
if exact.BoolVal(v) {
llvmvalue = llvm.ConstAllOnes(llvm.Int1Type())
} else {
llvmvalue = llvm.ConstNull(llvm.Int1Type())
}
return c.NewValue(llvmvalue, typ)
case isFloat(typ):
if isUntyped(typ) {
typ = types.Typ[types.Float64]
}
llvmtyp := c.types.ToLLVM(typ)
floatval, _ := exact.Float64Val(v)
llvmvalue := llvm.ConstFloat(llvmtyp, floatval)
return c.NewValue(llvmvalue, typ)
case typ == types.Typ[types.UnsafePointer]:
llvmtyp := c.types.ToLLVM(typ)
v, _ := exact.Uint64Val(v)
llvmvalue := llvm.ConstInt(llvmtyp, v, false)
return c.NewValue(llvmvalue, typ)
case isComplex(typ):
if isUntyped(typ) {
typ = types.Typ[types.Complex128]
}
llvmtyp := c.types.ToLLVM(typ)
floattyp := llvmtyp.StructElementTypes()[0]
llvmvalue := llvm.ConstNull(llvmtyp)
realv := exact.Real(v)
imagv := exact.Imag(v)
realfloatval, _ := exact.Float64Val(realv)
imagfloatval, _ := exact.Float64Val(imagv)
llvmre := llvm.ConstFloat(floattyp, realfloatval)
llvmim := llvm.ConstFloat(floattyp, imagfloatval)
llvmvalue = llvm.ConstInsertValue(llvmvalue, llvmre, []uint32{0})
llvmvalue = llvm.ConstInsertValue(llvmvalue, llvmim, []uint32{1})
return c.NewValue(llvmvalue, typ)
}
// Special case for string -> [](byte|rune)
if u, ok := typ.Underlying().(*types.Slice); ok && isInteger(u.Elem()) {
if v.Kind() == exact.String {
strval := c.NewConstValue(v, types.Typ[types.String])
return strval.Convert(typ).(*LLVMValue)
}
}
panic(fmt.Sprintf("unhandled: t=%s(%T), v=%v(%T)", c.types.TypeString(typ), typ, v, v))
}
// constValue returns the value of the constant with the
// dynamic type tag appropriate for c.Type().
func constValue(c *ssa.Const) value {
if c.IsNil() {
return zero(c.Type()) // typed nil
}
// By destination type:
switch t := c.Type().Underlying().(type) {
case *types.Basic:
// TODO(adonovan): eliminate untyped constants from SSA form.
switch t.Kind() {
case types.Bool, types.UntypedBool:
return exact.BoolVal(c.Value)
case types.Int, types.UntypedInt:
// Assume sizeof(int) is same on host and target.
return int(c.Int64())
case types.Int8:
return int8(c.Int64())
case types.Int16:
return int16(c.Int64())
case types.Int32, types.UntypedRune:
return int32(c.Int64())
case types.Int64:
return c.Int64()
case types.Uint:
// Assume sizeof(uint) is same on host and target.
return uint(c.Uint64())
case types.Uint8:
return uint8(c.Uint64())
case types.Uint16:
return uint16(c.Uint64())
case types.Uint32:
return uint32(c.Uint64())
case types.Uint64:
return c.Uint64()
case types.Uintptr:
// Assume sizeof(uintptr) is same on host and target.
return uintptr(c.Uint64())
case types.Float32:
return float32(c.Float64())
case types.Float64, types.UntypedFloat:
return c.Float64()
case types.Complex64:
return complex64(c.Complex128())
case types.Complex128, types.UntypedComplex:
return c.Complex128()
case types.String, types.UntypedString:
if c.Value.Kind() == exact.String {
return exact.StringVal(c.Value)
}
return string(rune(c.Int64()))
case types.UnsafePointer:
panic("unsafe.Pointer constant") // not possible
case types.UntypedNil:
// nil was handled above.
}
case *types.Slice:
switch et := t.Elem().Underlying().(type) {
case *types.Basic:
switch et.Kind() {
case types.Byte: // string -> []byte
var v []value
for _, b := range []byte(exact.StringVal(c.Value)) {
v = append(v, b)
}
return v
case types.Rune: // string -> []rune
var v []value
for _, r := range []rune(exact.StringVal(c.Value)) {
v = append(v, r)
}
return v
}
}
}
panic(fmt.Sprintf("constValue: Value.(type)=%T Type()=%s", c.Value, c.Type()))
}
// exprInternal contains the core of type checking of expressions.
// Must only be called by rawExpr.
//
func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
// make sure x has a valid state in case of bailout
// (was issue 5770)
x.mode = invalid
x.typ = Typ[Invalid]
switch e := e.(type) {
case *ast.BadExpr:
goto Error // error was reported before
case *ast.Ident:
check.ident(x, e, nil, nil)
case *ast.Ellipsis:
// ellipses are handled explicitly where they are legal
// (array composite literals and parameter lists)
check.error(e.Pos(), "invalid use of '...'")
goto Error
case *ast.BasicLit:
x.setConst(e.Kind, e.Value)
if x.mode == invalid {
check.invalidAST(e.Pos(), "invalid literal %v", e.Value)
goto Error
}
case *ast.FuncLit:
if sig, ok := check.typ(e.Type).(*Signature); ok {
// Anonymous functions are considered part of the
// init expression/func declaration which contains
// them: use existing package-level declaration info.
check.funcBody(check.decl, "", sig, e.Body)
x.mode = value
x.typ = sig
} else {
check.invalidAST(e.Pos(), "invalid function literal %s", e)
goto Error
}
case *ast.CompositeLit:
typ := hint
openArray := false
if e.Type != nil {
// [...]T array types may only appear with composite literals.
// Check for them here so we don't have to handle ... in general.
typ = nil
if atyp, _ := e.Type.(*ast.ArrayType); atyp != nil && atyp.Len != nil {
if ellip, _ := atyp.Len.(*ast.Ellipsis); ellip != nil && ellip.Elt == nil {
// We have an "open" [...]T array type.
// Create a new ArrayType with unknown length (-1)
// and finish setting it up after analyzing the literal.
typ = &Array{len: -1, elem: check.typ(atyp.Elt)}
openArray = true
}
}
if typ == nil {
typ = check.typ(e.Type)
}
}
if typ == nil {
check.error(e.Pos(), "missing type in composite literal")
goto Error
}
switch typ, _ := deref(typ); utyp := typ.Underlying().(type) {
case *Struct:
if len(e.Elts) == 0 {
break
}
fields := utyp.fields
if _, ok := e.Elts[0].(*ast.KeyValueExpr); ok {
// all elements must have keys
visited := make([]bool, len(fields))
for _, e := range e.Elts {
kv, _ := e.(*ast.KeyValueExpr)
if kv == nil {
check.error(e.Pos(), "mixture of field:value and value elements in struct literal")
continue
}
key, _ := kv.Key.(*ast.Ident)
if key == nil {
check.errorf(kv.Pos(), "invalid field name %s in struct literal", kv.Key)
continue
}
i := fieldIndex(utyp.fields, check.pkg, key.Name)
if i < 0 {
check.errorf(kv.Pos(), "unknown field %s in struct literal", key.Name)
continue
}
fld := fields[i]
check.recordUse(key, fld)
// 0 <= i < len(fields)
if visited[i] {
check.errorf(kv.Pos(), "duplicate field name %s in struct literal", key.Name)
continue
}
visited[i] = true
check.expr(x, kv.Value)
etyp := fld.typ
if !check.assignment(x, etyp) {
if x.mode != invalid {
check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
}
continue
}
}
} else {
// no element must have a key
for i, e := range e.Elts {
if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
check.error(kv.Pos(), "mixture of field:value and value elements in struct literal")
continue
}
check.expr(x, e)
if i >= len(fields) {
check.error(x.pos(), "too many values in struct literal")
break // cannot continue
}
// i < len(fields)
etyp := fields[i].typ
if !check.assignment(x, etyp) {
if x.mode != invalid {
check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
}
continue
}
}
if len(e.Elts) < len(fields) {
check.error(e.Rbrace, "too few values in struct literal")
// ok to continue
}
}
case *Array:
n := check.indexedElts(e.Elts, utyp.elem, utyp.len)
// if we have an "open" [...]T array, set the length now that we know it
if openArray {
utyp.len = n
}
case *Slice:
check.indexedElts(e.Elts, utyp.elem, -1)
case *Map:
visited := make(map[interface{}][]Type, len(e.Elts))
for _, e := range e.Elts {
kv, _ := e.(*ast.KeyValueExpr)
if kv == nil {
check.error(e.Pos(), "missing key in map literal")
continue
}
check.expr(x, kv.Key)
if !check.assignment(x, utyp.key) {
if x.mode != invalid {
check.errorf(x.pos(), "cannot use %s as %s key in map literal", x, utyp.key)
}
continue
}
if x.mode == constant {
duplicate := false
// if the key is of interface type, the type is also significant when checking for duplicates
if _, ok := utyp.key.Underlying().(*Interface); ok {
for _, vtyp := range visited[x.val] {
if Identical(vtyp, x.typ) {
duplicate = true
break
}
}
visited[x.val] = append(visited[x.val], x.typ)
} else {
_, duplicate = visited[x.val]
visited[x.val] = nil
}
if duplicate {
check.errorf(x.pos(), "duplicate key %s in map literal", x.val)
continue
}
}
check.exprWithHint(x, kv.Value, utyp.elem)
if !check.assignment(x, utyp.elem) {
if x.mode != invalid {
check.errorf(x.pos(), "cannot use %s as %s value in map literal", x, utyp.elem)
}
continue
}
}
default:
check.errorf(e.Pos(), "invalid composite literal type %s", typ)
goto Error
}
x.mode = value
x.typ = typ
case *ast.ParenExpr:
kind := check.rawExpr(x, e.X, nil)
x.expr = e
return kind
case *ast.SelectorExpr:
check.selector(x, e)
case *ast.IndexExpr:
check.expr(x, e.X)
if x.mode == invalid {
goto Error
}
valid := false
length := int64(-1) // valid if >= 0
switch typ := x.typ.Underlying().(type) {
case *Basic:
if isString(typ) {
valid = true
if x.mode == constant {
length = int64(len(exact.StringVal(x.val)))
}
// an indexed string always yields a byte value
// (not a constant) even if the string and the
// index are constant
x.mode = value
x.typ = UniverseByte // use 'byte' name
}
case *Array:
valid = true
length = typ.len
if x.mode != variable {
x.mode = value
}
x.typ = typ.elem
case *Pointer:
if typ, _ := typ.base.Underlying().(*Array); typ != nil {
valid = true
length = typ.len
x.mode = variable
x.typ = typ.elem
}
case *Slice:
valid = true
x.mode = variable
x.typ = typ.elem
case *Map:
var key operand
check.expr(&key, e.Index)
if !check.assignment(&key, typ.key) {
if key.mode != invalid {
check.invalidOp(key.pos(), "cannot use %s as map index of type %s", &key, typ.key)
}
goto Error
}
x.mode = mapindex
x.typ = typ.elem
x.expr = e
return expression
}
if !valid {
check.invalidOp(x.pos(), "cannot index %s", x)
goto Error
}
if e.Index == nil {
check.invalidAST(e.Pos(), "missing index for %s", x)
goto Error
}
check.index(e.Index, length)
// ok to continue
case *ast.SliceExpr:
check.expr(x, e.X)
if x.mode == invalid {
goto Error
}
valid := false
length := int64(-1) // valid if >= 0
switch typ := x.typ.Underlying().(type) {
case *Basic:
if isString(typ) {
if slice3(e) {
check.invalidOp(x.pos(), "3-index slice of string")
goto Error
}
valid = true
if x.mode == constant {
length = int64(len(exact.StringVal(x.val)))
}
// spec: "For untyped string operands the result
// is a non-constant value of type string."
if typ.kind == UntypedString {
x.typ = Typ[String]
}
}
case *Array:
valid = true
length = typ.len
if x.mode != variable {
check.invalidOp(x.pos(), "cannot slice %s (value not addressable)", x)
goto Error
}
x.typ = &Slice{elem: typ.elem}
case *Pointer:
if typ, _ := typ.base.Underlying().(*Array); typ != nil {
valid = true
length = typ.len
x.typ = &Slice{elem: typ.elem}
}
case *Slice:
valid = true
// x.typ doesn't change
}
if !valid {
check.invalidOp(x.pos(), "cannot slice %s", x)
goto Error
}
x.mode = value
// spec: "Only the first index may be omitted; it defaults to 0."
if slice3(e) && (e.High == nil || sliceMax(e) == nil) {
check.error(e.Rbrack, "2nd and 3rd index required in 3-index slice")
goto Error
}
// check indices
var ind [3]int64
for i, expr := range []ast.Expr{e.Low, e.High, sliceMax(e)} {
x := int64(-1)
switch {
case expr != nil:
// The "capacity" is only known statically for strings, arrays,
// and pointers to arrays, and it is the same as the length for
// those types.
max := int64(-1)
if length >= 0 {
max = length + 1
}
if t, ok := check.index(expr, max); ok && t >= 0 {
x = t
}
case i == 0:
// default is 0 for the first index
x = 0
case length >= 0:
// default is length (== capacity) otherwise
x = length
}
ind[i] = x
}
// constant indices must be in range
// (check.index already checks that existing indices >= 0)
L:
for i, x := range ind[:len(ind)-1] {
if x > 0 {
for _, y := range ind[i+1:] {
if y >= 0 && x > y {
check.errorf(e.Rbrack, "invalid slice indices: %d > %d", x, y)
break L // only report one error, ok to continue
}
}
}
}
case *ast.TypeAssertExpr:
check.expr(x, e.X)
if x.mode == invalid {
goto Error
}
xtyp, _ := x.typ.Underlying().(*Interface)
if xtyp == nil {
check.invalidOp(x.pos(), "%s is not an interface", x)
goto Error
}
// x.(type) expressions are handled explicitly in type switches
if e.Type == nil {
check.invalidAST(e.Pos(), "use of .(type) outside type switch")
goto Error
}
T := check.typ(e.Type)
if T == Typ[Invalid] {
goto Error
}
check.typeAssertion(x.pos(), x, xtyp, T)
x.mode = commaok
x.typ = T
case *ast.CallExpr:
return check.call(x, e)
case *ast.StarExpr:
check.exprOrType(x, e.X)
switch x.mode {
case invalid:
goto Error
case typexpr:
x.typ = &Pointer{base: x.typ}
default:
if typ, ok := x.typ.Underlying().(*Pointer); ok {
x.mode = variable
x.typ = typ.base
} else {
check.invalidOp(x.pos(), "cannot indirect %s", x)
goto Error
}
}
case *ast.UnaryExpr:
check.expr(x, e.X)
if x.mode == invalid {
goto Error
}
check.unary(x, e.Op)
if x.mode == invalid {
goto Error
}
if e.Op == token.ARROW {
x.expr = e
return statement // receive operations may appear in statement context
}
case *ast.BinaryExpr:
check.binary(x, e.X, e.Y, e.Op)
if x.mode == invalid {
goto Error
}
case *ast.KeyValueExpr:
// key:value expressions are handled in composite literals
check.invalidAST(e.Pos(), "no key:value expected")
goto Error
case *ast.ArrayType, *ast.StructType, *ast.FuncType,
*ast.InterfaceType, *ast.MapType, *ast.ChanType:
x.mode = typexpr
x.typ = check.typ(e)
// Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue
// even though check.typ has already called it. This is fine as both
// times the same expression and type are recorded. It is also not a
// performance issue because we only reach here for composite literal
// types, which are comparatively rare.
default:
panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
}
// everything went well
x.expr = e
return expression
Error:
x.mode = invalid
x.expr = e
return statement // avoid follow-up errors
}
// literalValue returns the value of the literal with the
// dynamic type tag appropriate for l.Type().
func literalValue(l *ssa.Literal) value {
if l.IsNil() {
return zero(l.Type()) // typed nil
}
// By destination type:
switch t := l.Type().Underlying().(type) {
case *types.Basic:
switch t.Kind() {
case types.Bool, types.UntypedBool:
return exact.BoolVal(l.Value)
case types.Int, types.UntypedInt:
// Assume sizeof(int) is same on host and target.
return int(l.Int64())
case types.Int8:
return int8(l.Int64())
case types.Int16:
return int16(l.Int64())
case types.Int32, types.UntypedRune:
return int32(l.Int64())
case types.Int64:
return l.Int64()
case types.Uint:
// Assume sizeof(uint) is same on host and target.
return uint(l.Uint64())
case types.Uint8:
return uint8(l.Uint64())
case types.Uint16:
return uint16(l.Uint64())
case types.Uint32:
return uint32(l.Uint64())
case types.Uint64:
return l.Uint64()
case types.Uintptr:
// Assume sizeof(uintptr) is same on host and target.
return uintptr(l.Uint64())
case types.Float32:
return float32(l.Float64())
case types.Float64, types.UntypedFloat:
return l.Float64()
case types.Complex64:
return complex64(l.Complex128())
case types.Complex128, types.UntypedComplex:
return l.Complex128()
case types.String, types.UntypedString:
if l.Value.Kind() == exact.String {
return exact.StringVal(l.Value)
}
return string(rune(l.Int64()))
case types.UnsafePointer:
panic("unsafe.Pointer literal") // not possible
case types.UntypedNil:
// nil was handled above.
}
case *types.Slice:
switch et := t.Elem().Underlying().(type) {
case *types.Basic:
switch et.Kind() {
case types.Byte: // string -> []byte
var v []value
for _, b := range []byte(exact.StringVal(l.Value)) {
v = append(v, b)
}
return v
case types.Rune: // string -> []rune
var v []value
for _, r := range []rune(exact.StringVal(l.Value)) {
v = append(v, r)
}
return v
}
}
}
panic(fmt.Sprintf("literalValue: Value.(type)=%T Type()=%s", l.Value, l.Type()))
}