The code of my client-side app is:

package main

import (
	"net/http"
	"strings"

	"github.com/gopherjs/gopherjs/js"
)

var JS = js.Global
var Document = JS.Get("document")

func main() {
	f := Document.Call("querySelector", "#foo")

	f.Set("class", "c1")
	f.Set("innerHTML", "<h1>Hello World</h1>")

	d := Document.Call("createElement", "Div")
	d.Set("innerHTML", "New element")
	f.Call("appendChild", d)

	b := Document.Call("createElement", "Button")
	b.Set("innerHTML", "click here")

	b.Call("addEventListener", "click", post_it)

	f.Call("appendChild", b)
}

// Utility function for testing POST requests in GopherJs:
func post_it() {

	jsonStr := `{"title":"test","data":"none"}`

	println(jsonStr)

	resp, err := http.Post("/post", "application/json", strings.NewReader(jsonStr))

	if err != nil {
		// handle error
		println(err)
	}
	defer resp.Body.Close()

}

..in other words, the app above (in Go via GopherJS) does not seem to compile to valid JavaScript when http.Post is used.

If I comment out the http.Post part, the app works as expected (but of course, it defeats the purpose):

// Utility function for testing POST requests in GopherJs:
func post_it() {

	jsonStr := `{"title":"test","data":"none"}`

	println(jsonStr)

	// resp, err := http.Post("/post", "application/json", strings.NewReader(jsonStr))

	// if err != nil {
	// 	// handle error
	// 	println(err)
	// }
	// defer resp.Body.Close()

}

Likely related to (and possible duplicate of?) #575

This works, though:

func Post() {

	var url = "http://localhost:8000"

	req := js.Global.Get("XMLHttpRequest").New()
	req.Call("addEventListener", "load", func() {
		println(req.Get("responseText").String())
	})
	req.Call("open", "POST", url, true)
	req.Call("send")
}

I won't have time to give it a close look until the weekend, but one possibility is that you are making a blocking call from a JavaScript event handler, which may not be correctly interacting with the goroutine scheduler.

Can you try replacing b.Call("addEventListener", "click", post_it) with b.Call("addEventListener", "click", func() { go post_it() })?

Thank you for your answer @nevkontakte. I tried your suggestion, but it I still get the same warning.

Alternatively, I suppose I could use the GopherJS wrapper around the Fetch() api to do POST requests from the client-side (instead of using XMLHttpRequest).

Are there a few examples on how to use fetch() with GopherJS() to do GET, POST requests?

@serge-hulne I've taken a closer look at your example. There are several places in the generated JavaScript where Firefox shows this warning, but in all cases it is benign. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Stmt_after_return has a bit more info about this warning, at its main purpose is to catch mistakes in hand-written JavaScript, but not so much in compiled code. Note that it's just a warning, not an actual error.

To be a bit more specific, this warnings seem to happen in Go functions that follow this pattern:

func doSomething() returnType {
  for {
    // Do something.
    return result
  }
}

GopherJS transpiles this into JavaScript code that looks roughly like this:

function doSomething() {
  whille(true) {
    // Do something.
    return result;
    continue; // This is the unreachable statement, but also entirely harmless.
  }
}

In reality the generated code is a bit more complicated because happens in "flattened" functions where GopherJS uses a switch-case to jump between code blocks, and this "continue" statement is needed to ensure correctness of the loop. I'll see if it's possible to change the code generation to avoid this unnecessary statement, but the only difference it'll make is a marginal decrease in the generated code size.

For you I recommend just continue using net/http and ignore the warning.

All right. Thank you.