// Copyright (c) 2023 l-m.dev. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module wasm

// WebAssembly feature gating for the native backend.
//
// `wasm-opt` (Binaryen) and `wasm-validate` (WABT) accept *different* flag
// spellings for the same features (e.g. Binaryen `--enable-exception-handling`
// vs WABT `--enable-exceptions`; Binaryen `--enable-nontrapping-float-to-int`
// vs WABT `--disable-saturating-float-to-int`). The logical feature set is
// therefore defined once here and rendered into each tool's own vocabulary.
//
// The default build enables only the Safari-15 "floor" features; everything
// else is opt-in via a `-d <name>` compile define. This keeps a default
// `-os browser`/`-os wasi` build from silently emitting opcodes past the
// baseline (the old `wasm-opt -all` enabled memory64/relaxed-SIMD/exnref/gc).

// wasm_opt_min_version is the Binaryen version the toolchain pins
// (see cmd/tools/install_binaryen.vsh). Used only for a soft warning.
const wasm_opt_min_version = 112

enum WasmFeature {
	reference_types
	bulk_memory
	multivalue
	sign_ext
	mutable_globals
	nontrapping_f2i
	simd
	gc
	exception_handling
	tail_call
	threads
	memory64
	relaxed_simd
	extended_const
}

// wasm_all_features lists every modelled feature, used to compute the WABT
// validator argument set relative to its defaults.
const wasm_all_features = [WasmFeature.reference_types, .bulk_memory, .multivalue, .sign_ext,
	.mutable_globals, .nontrapping_f2i, .simd, .gc, .exception_handling, .tail_call, .threads,
	.memory64, .relaxed_simd, .extended_const]

// wasm_floor_features is the always-on Safari-15 baseline. It covers everything
// the emitter produces today: ref.func/ref.null, memory.copy/fill/init,
// multi-return, sign_extendN, the mutable __vsp/__heap_base globals, and
// saturating (nontrapping) float->int casts.
const wasm_floor_features = [WasmFeature.reference_types, .bulk_memory, .multivalue, .sign_ext,
	.mutable_globals, .nontrapping_f2i]

// wasm_optin_defines maps a `-d <name>` compile define to the feature it enables.
const wasm_optin_defines = {
	'wasm_gc':             WasmFeature.gc
	'wasm_exceptions':     WasmFeature.exception_handling
	'wasm_tail_call':      WasmFeature.tail_call
	'wasm_simd':           WasmFeature.simd
	'wasm_threads':        WasmFeature.threads
	'wasm_memory64':       WasmFeature.memory64
	'wasm_relaxed_simd':   WasmFeature.relaxed_simd
	'wasm_extended_const': WasmFeature.extended_const
}

struct FeatureFlag {
	binaryen        string // wasm-opt flag, e.g. '--enable-reference-types'
	wabt            string // WABT feature token, e.g. 'reference-types'
	wabt_default_on bool   // whether wasm-validate enables it without any flag
}

fn (f WasmFeature) flag() FeatureFlag {
	return match f {
		.reference_types {
			FeatureFlag{
				binaryen:        '--enable-reference-types'
				wabt:            'reference-types'
				wabt_default_on: true
			}
		}
		.bulk_memory {
			FeatureFlag{
				binaryen:        '--enable-bulk-memory'
				wabt:            'bulk-memory'
				wabt_default_on: true
			}
		}
		.multivalue {
			FeatureFlag{
				binaryen:        '--enable-multivalue'
				wabt:            'multi-value'
				wabt_default_on: true
			}
		}
		.sign_ext {
			FeatureFlag{
				binaryen:        '--enable-sign-ext'
				wabt:            'sign-extension'
				wabt_default_on: true
			}
		}
		.mutable_globals {
			FeatureFlag{
				binaryen:        '--enable-mutable-globals'
				wabt:            'mutable-globals'
				wabt_default_on: true
			}
		}
		.nontrapping_f2i {
			FeatureFlag{
				binaryen:        '--enable-nontrapping-float-to-int'
				wabt:            'saturating-float-to-int'
				wabt_default_on: true
			}
		}
		.simd {
			FeatureFlag{
				binaryen:        '--enable-simd'
				wabt:            'simd'
				wabt_default_on: true
			}
		}
		.gc {
			FeatureFlag{
				binaryen:        '--enable-gc'
				wabt:            'gc'
				wabt_default_on: false
			}
		}
		.exception_handling {
			FeatureFlag{
				binaryen:        '--enable-exception-handling'
				wabt:            'exceptions'
				wabt_default_on: false
			}
		}
		.tail_call {
			FeatureFlag{
				binaryen:        '--enable-tail-call'
				wabt:            'tail-call'
				wabt_default_on: false
			}
		}
		.threads {
			FeatureFlag{
				binaryen:        '--enable-threads'
				wabt:            'threads'
				wabt_default_on: false
			}
		}
		.memory64 {
			FeatureFlag{
				binaryen:        '--enable-memory64'
				wabt:            'memory64'
				wabt_default_on: false
			}
		}
		.relaxed_simd {
			FeatureFlag{
				binaryen:        '--enable-relaxed-simd'
				wabt:            'relaxed-simd'
				wabt_default_on: false
			}
		}
		.extended_const {
			FeatureFlag{
				binaryen:        '--enable-extended-const'
				wabt:            'extended-const'
				wabt_default_on: false
			}
		}
	}
}

// enabled_wasm_features returns the floor set plus any opt-in feature whose
// `-d` define was passed on the command line.
fn (g &Gen) enabled_wasm_features() []WasmFeature {
	mut feats := wasm_floor_features.clone()
	for define, feat in wasm_optin_defines {
		if define in g.pref.compile_defines {
			feats << feat
		}
	}
	return apply_feature_implications(feats)
}

// apply_feature_implications expands `feats` with any feature implied by another.
// Relaxed SIMD extends the SIMD/v128 feature, so requesting it must also enable
// SIMD. Otherwise wabt_validate_args() emits `--disable-simd --enable-relaxed-simd`
// and wasm-opt runs from `-mvp` without `--enable-simd`, so a `-d wasm_relaxed_simd`
// build still fails under `-wasm-validate`/`-prod`.
fn apply_feature_implications(feats []WasmFeature) []WasmFeature {
	mut res := feats.clone()
	if WasmFeature.relaxed_simd in res && WasmFeature.simd !in res {
		res << .simd
	}
	return res
}

// binaryen_feature_flags renders the feature set into `wasm-opt` flags. It
// starts from `-mvp` (all non-MVP features off) and enables only the allowlist,
// so emitting an opcode outside the set makes wasm-opt itself fail rather than
// silently optimise it through.
fn binaryen_feature_flags(feats []WasmFeature) string {
	mut flags := ['-mvp']
	for feat in feats {
		flags << feat.flag().binaryen
	}
	return flags.join(' ')
}

// wabt_validate_args renders the feature set into `wasm-validate` arguments,
// relative to WABT's defaults: disable any default-on feature not in the set
// (e.g. `--disable-simd` on a floor build), and enable any default-off feature
// that is in the set. This gives the validator teeth - a stray above-floor
// opcode fails validation instead of passing under WABT's permissive defaults.
fn wabt_validate_args(feats []WasmFeature) []string {
	mut args := []string{}
	for feat in wasm_all_features {
		ff := feat.flag()
		enabled := feat in feats
		if ff.wabt_default_on && !enabled {
			args << '--disable-${ff.wabt}'
		} else if !ff.wabt_default_on && enabled {
			args << '--enable-${ff.wabt}'
		}
	}
	return args
}