feat: support build tag detection (#379)

* fix: require WASM env for bench and fuzz * chore: rely on auto env switch * feat: add self-destruct notifications * feat: support build tag analysis

Author: x1unix

web/public/examples/templates/bench_test.go

@@ -1,7 +1,12 @@
+//go:build wasm
+
 package main
 
 import "testing"
 
+// **Important:** This benchmark will be executed using WebAssembly as original Go Playground API doesn't support benchmarks and fuzzing.
+// See: https://stackoverflow.com/questions/54574814/go-benchmark-run-from-main-go-playground
+
 func doJob() {
 // Put here code to benchmark
 }

web/public/examples/testing/bench_test.go

@@ -1,3 +1,5 @@
+//go:build wasm
+
 // The Go testing package contains a benchmarking facility
 // that can be used to examine the performance of your Go code.
 //
@@ -6,6 +8,9 @@
 // See: https://dave.cheney.net/2013/06/30/how-to-write-benchmarks-in-go
 package main
 
+// **Important:** This benchmark will be executed using WebAssembly as original Go Playground API doesn't support benchmarks and fuzzing.
+// See: https://stackoverflow.com/questions/54574814/go-benchmark-run-from-main-go-playground
+
 import "testing"
 
 // In this example we’re going to benchmark the speed of computing the 10th number in the Fibonacci series.

web/public/examples/testing/fuzz_test.go

@@ -1,3 +1,5 @@
+//go:build wasm
+
 // This tutorial introduces the basics of fuzzing in Go.
 // With fuzzing, random data is run against your test in an attempt to find vulnerabilities or crash-causing inputs.
 // Some examples of vulnerabilities that can be found by fuzzing are SQL injection, buffer overflow,
@@ -12,6 +14,9 @@ import (
 "unicode/utf8"
 )
 
+// **Important:** This test will be executed using WebAssembly as original Go Playground API doesn't support benchmarks and fuzzing.
+// See: https://stackoverflow.com/questions/54574814/go-benchmark-run-from-main-go-playground
+
 // This function will accept a string, loop over it a byte at a time, and return the reversed string at the end.
 func Reverse(s string) (string, error) {
 if !utf8.ValidString(s) {

web/public/examples/wasm/main.go

@@ -6,10 +6,6 @@
 // Go allows calling JavaScript functions from browser and also export functions to JavaScript.
 package main
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-// ⚠️ Attention: please select "WebAssembly" environment in top right corner.
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-
 import (
 "fmt"
 

web/src/lib/sourceutil/analysis.ts

@@ -0,0 +1,13 @@
+const wasmBuildTagRegex = /^\/\/go:build\s(js|wasm)(\s(&&|\|\|)\s(js|wasm))?/
+
+const isGoFile = (fileName: string) => fileName.endsWith('.go')
+
+/**
+ * Checks if Go program source files contain WebAssembly build constraints.
+ *
+ * For example: `//go:build wasm`
+ */
+export const requiresWasmEnvironment = (files: Record<string, string>): boolean =>
+ Object.entries(files)
+ .filter(([name]) => isGoFile(name))
+ .some(([, src]) => src.match(wasmBuildTagRegex))

web/src/lib/sourceutil/flags.ts

@@ -0,0 +1,18 @@
+interface GoProgramInfo {
+ isTest?: boolean
+ hasBenchmark?: boolean
+ hasFuzz?: boolean
+}
+
+/**
+ * Returns command line args for Go test binary based on server build response.
+ */
+export const buildGoTestFlags = ({ isTest, hasBenchmark, hasFuzz }: GoProgramInfo): string[] => {
+ const flags: Array<[string, boolean | undefined]> = [
+ ['-test.v', isTest],
+ ['-test.bench=.', hasBenchmark],
+ ['-test.fuzz=.', hasFuzz],
+ ]
+
+ return flags.filter(([, keep]) => !!keep).map(([arg]) => arg)
+}

web/src/lib/sourceutil/index.ts

@@ -0,0 +1,2 @@
+export * from './flags'
+export * from './analysis'

web/src/store/dispatchers/build.ts

@@ -2,7 +2,8 @@ import { TargetType } from '~/services/config'
 import { getImportObject, goRun } from '~/services/go'
 import { setTimeoutNanos, SECOND } from '~/utils/duration'
 import { instantiateStreaming } from '~/lib/go'
-import client, { type BuildResponse, type EvalEvent, EvalEventKind } from '~/services/api'
+import { buildGoTestFlags, requiresWasmEnvironment } from '~/lib/sourceutil'
+import client, { type EvalEvent, EvalEventKind } from '~/services/api'
 import { isProjectRequiresGoMod, goModFile, goModTemplate } from '~/services/examples'
 
 import { type DispatchFn, type StateProvider } from '../helpers'
@@ -134,19 +135,6 @@ const fetchWasmWithProgress = async (dispatch: DispatchFn, fileName: string) =>
  }
 }
 
-/**
- * Returns command line args for Go test binary based on server build response.
- */
-const buildGoTestFlags = ({ isTest, hasBenchmark, hasFuzz }: BuildResponse): string[] => {
- const flags: Array<[string, boolean | undefined]> = [
- ['-test.v', isTest],
- ['-test.bench=.', hasBenchmark],
- ['-test.fuzz=.', hasFuzz],
- ]
-
- return flags.filter(([, keep]) => !!keep).map(([arg]) => arg)
-}
-
 export const runFileDispatcher: Dispatcher = async (dispatch: DispatchFn, getState: StateProvider) => {
  dispatch(newRemoveNotificationAction(NotificationIDs.WASMAppExitError))
  dispatch(newRemoveNotificationAction(NotificationIDs.GoModMissing))
@@ -155,7 +143,7 @@ export const runFileDispatcher: Dispatcher = async (dispatch: DispatchFn, getSta
  const {
  settings,
  workspace,
- runTarget: { target, backend },
+ runTarget: { target: selectedTarget, backend },
  } = getState()
 
  let { files, selectedFile } = workspace
@@ -205,7 +193,30 @@ export const runFileDispatcher: Dispatcher = async (dispatch: DispatchFn, getSta
  })
  }
 
- switch (target) {
+ // Force use WebAssembly for execution if source code contains go:build constraints.
+ let runTarget = selectedTarget
+ if (runTarget !== TargetType.WebAssembly && requiresWasmEnvironment(files)) {
+ runTarget = TargetType.WebAssembly
+ dispatch(
+ newAddNotificationAction({
+ id: NotificationIDs.GoTargetSwitched,
+ type: NotificationType.Warning,
+ title: 'Go environment temporarily changed',
+ description: 'This program will be executed using WebAssembly as Go program contains "//go:build" tag.',
+ canDismiss: true,
+ actions: [
+ {
+ key: 'ok',
+ label: 'Ok',
+ primary: true,
+ onClick: () => dispatch(newRemoveNotificationAction(NotificationIDs.GoTargetSwitched)),
+ },
+ ],
+ }),
+ )
+ }
+
+ switch (runTarget) {
  case TargetType.Server: {
  // TODO: vet
  const res = await client.run(files, false, backend)
@@ -239,7 +250,7 @@ export const runFileDispatcher: Dispatcher = async (dispatch: DispatchFn, getSta
  break
  }
  default:
- dispatch(newErrorAction(`AppError: Unknown Go runtime type "${target}"`))
+ dispatch(newErrorAction(`AppError: Unknown Go runtime type "${runTarget}"`))
  }
  } catch (err: any) {
  dispatch(newErrorAction(err.message))

web/src/store/helpers.ts

@@ -1,10 +1,11 @@
 import { type Action, type ActionType } from './actions'
+import type { Dispatcher } from './dispatchers'
 import { type State } from './state'
 
 export type Reducer<S, T> = (s: S, a: Action<T>) => S
 export type ActionReducers<T> = { [k in keyof typeof ActionType | string]: Reducer<T, any> }
 
-export type DispatchFn = <T = any>(a: Action<T>) => any
+export type DispatchFn = <T = any>(a: Action<T> | Dispatcher) => any
 export type StateProvider = () => State
 
 /**

web/src/store/notifications/dispatchers.ts

@@ -0,0 +1,15 @@
+import type { Dispatcher } from '../dispatchers'
+import type { DispatchFn, StateProvider } from '../helpers'
+import { newAddNotificationAction, newRemoveNotificationAction } from './actions'
+import type { Notification } from './state'
+
+/**
+ * Returns dispatcher that will show a notification which will disappear after a specified delay.
+ */
+export const dispatchNotificationWithTimeout = (notification: Notification, timeout = 5000): Dispatcher => {
+ return (dispatch: DispatchFn, _: StateProvider) => {
+ const { id } = notification
+ setTimeout(() => dispatch(newRemoveNotificationAction(id)), timeout)
+ dispatch(newAddNotificationAction(notification))
+ }
+}