Fixing env watcher for godebug

grantnelson-wf · grantnelson-wf · commit be1cb068a0a9 · 2024-05-31T13:20:33.000-06:00
diff --git a/compiler/natives/src/internal/godebug/godebug.go b/compiler/natives/src/internal/godebug/godebug.go
@@ -5,6 +5,8 @@ package godebug
 
 import (
 	"sync"
+
+	"github.com/gopherjs/gopherjs/js"
 )
 
 type Setting struct {
@@ -37,6 +39,57 @@ func (s *Setting) Value() string {
 	return *s.value.Load()
 }
 
+const godebugEnvKey = `GODEBUG`
+
+var injectWatcher sync.Once
+var godebugUpdate func(def, env string)
+
+// setUpdate is provided by package runtime.
+// It calls update(def, env), where def is the default GODEBUG setting
+// and env is the current value of the $GODEBUG environment variable.
+// After that first call, the runtime calls update(def, env)
+// again each time the environment variable changes
+// (due to use of os.Setenv, for example).
+func setUpdate(update func(def, env string)) {
+	injectWatcher.Do(func() {
+		js.Global.Call(`$injectGoDebugEnvWatcher`, godebugNotify)
+	})
+	godebugUpdate = update
+	godebugEnv := getEnvString(godebugEnvKey)
+	godebugNotify(godebugEnvKey, godebugEnv)
+}
+
+func getEnvString(key string) string {
+	process := js.Global.Get(`process`)
+	if process == js.Undefined {
+		return ``
+	}
+
+	env := process.Get(`env`)
+	if env == js.Undefined {
+		return ``
+	}
+
+	value := env.Get(key)
+	if value == js.Undefined {
+		return ``
+	}
+
+	return value.String()
+}
+
+// godebugNotify is the function injected into process.env
+// and called anytime an environment variable is set.
+func godebugNotify(key, value string) {
+	update := godebugUpdate
+	if update == nil || key != godebugEnvKey {
+		return
+	}
+
+	godebugDefault := ``
+	update(godebugDefault, value)
+}
+
 func update(def, env string) {
 	updateMu.Lock()
 	defer updateMu.Unlock()
diff --git a/compiler/prelude/prelude.js b/compiler/prelude/prelude.js
@@ -576,3 +576,13 @@ var $sliceData = (slice, typ) => {
     }
     return $indexPtr(slice.$array, slice.$offset, typ.elem);
 };
+
+var $injectGoDebugEnvWatcher = (onEnvChange) => {
+    process.env = new Proxy(process.env, {
+        set(target, key, value) {
+            onEnvChange(key, value);
+            target[key] = value;
+            return true;
+        }
+    });
+};
diff --git a/tests/runtime_test.go b/tests/runtime_test.go
@@ -5,7 +5,10 @@ package tests
 import (
 	"fmt"
 	"runtime"
+	"strconv"
+	"strings"
 	"testing"
+	_ "unsafe"
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/gopherjs/gopherjs/js"
@@ -160,3 +163,42 @@ func TestCallers(t *testing.T) {
 		panic("panic")
 	})
 }
+
+// Need this to tunnel into `internal/godebug` and run a test
+// without causing a dependency cycle with the `testing` package.
+//
+//go:linkname godebug_setUpdate internal/godebug.setUpdate
+func godebug_setUpdate(update func(string, string))
+
+func Test_GoDebugInjection(t *testing.T) {
+	buf := []string{}
+	update := func(def, env string) {
+		if def != `` {
+			t.Errorf(`Expected the default value to be empty but got %q`, def)
+		}
+		buf = append(buf, strconv.Quote(env))
+	}
+	check := func(want string) {
+		if got := strings.Join(buf, `, `); got != want {
+			t.Errorf(`Unexpected result: got: %q, want: %q`, got, want)
+		}
+		buf = buf[:0]
+	}
+
+	// Call it multiple times to ensure that the watcher is only injected once.
+	// Each one of these calls should emit an update first, then when GODEBUG is set.
+	godebug_setUpdate(update)
+	godebug_setUpdate(update)
+	check(`"", ""`) // two empty strings for initial update calls.
+
+	t.Setenv(`GODEBUG`, `gopherJSTest=ben`)
+	check(`"gopherJSTest=ben"`) // must only be once for update for new value.
+
+	godebug_setUpdate(update)
+	check(`"gopherJSTest=ben"`) // must only be once for initial update with already set value.
+
+	t.Setenv(`GODEBUG`, `gopherJSTest=tom`)
+	t.Setenv(`GODEBUG`, `gopherJSTest=sam`)
+	t.Setenv(`NOT_GODEBUG`, `gopherJSTest=bob`)
+	check(`"gopherJSTest=tom", "gopherJSTest=sam"`)
+}
