/**

* @fileoverview Built-in elements providing core WebAssembly functionality.

*

* Each builtin is linked to its definition in std/assembly/builtins.ts.

* When its prototype is called, the compiler recognizes the `@builtin`

* decorator, looks up the respective handler in the global builtins map

* and executes it, with the handler directly emitting WebAssembly code

* according to context.

*

* Builtins can be categorized into core builtins that typically are generic

* and emit code directly and aliases calling core builtins with overridden

* contexts. The latter is used by inline assembler aliases of WebAssembly

* instructions, like `i64.load8_u` deferring to `<i64>load<u8>`.

*

* The `contextIsExact` modifier is used to force a specific instruction

* family. A `i32.store8` deferring to `<i32>store<i8>` for example is

* ambiguous in that the input can still be an i32 or an i64, leading to

* either an `i32.store8` or an `i64.store8`, so `i32` is forced there.

* This behavior is indicated by `from i32/i64` in the comments below.

*

* @license Apache-2.0

*/

// TODO: Add builtins for `i32.add` etc. that do not have a core builtin.

import {

Compiler,

Constraints,

RuntimeFeatures

} from "./compiler";

import {

DiagnosticCode,

DiagnosticCategory

} from "./diagnostics";

import {

Expression,

LiteralKind,

StringLiteralExpression,

CallExpression,

NodeKind,

LiteralExpression,

ArrayLiteralExpression

} from "./ast";

import {

Type,

TypeKind,

TypeFlags

} from "./types";

import {

BinaryOp,

UnaryOp,

HostOp,

AtomicRMWOp,

SIMDExtractOp,

SIMDReplaceOp,

SIMDShiftOp,

SIMDTernaryOp,

NativeType,

ExpressionRef,

ExpressionId,

getExpressionId,

getExpressionType,

getConstValueI64High,

getConstValueI64Low,

getConstValueI32,

getConstValueF32,

getConstValueF64,

Relooper,

RelooperBlockRef,

SIMDLoadOp,

getLocalGetIndex,

createType,

ExpressionRunnerFlags

} from "./module";

import {

ElementKind,

FunctionPrototype,

Field,

Global,

DecoratorFlags,

Element,

ClassPrototype

} from "./program";

import {

FlowFlags,

LocalFlags

} from "./flow";

import {

ReportMode

} from "./resolver";

import {

CommonFlags,

Feature,

featureToString,

TypeinfoFlags

} from "./common";

import {

writeI8,

writeI16,

writeI32,

writeF32,

writeF64,

isPowerOf2

} from "./util";

/** Internal names of various compiler built-ins. */

export namespace BuiltinNames {

// compiler-generated

export const start = "~start";

export const started = "~started";

export const argumentsLength = "~argumentsLength";

export const setArgumentsLength = "~setArgumentsLength";

// std/builtins.ts

export const abort = "~lib/builtins/abort";

export const trace = "~lib/builtins/trace";

export const seed = "~lib/builtins/seed";

export const isInteger = "~lib/builtins/isInteger";

export const isFloat = "~lib/builtins/isFloat";

export const isBoolean = "~lib/builtins/isBoolean";

export const isSigned = "~lib/builtins/isSigned";

export const isReference = "~lib/builtins/isReference";

export const isString = "~lib/builtins/isString";

export const isArray = "~lib/builtins/isArray";

export const isArrayLike = "~lib/builtins/isArrayLike";

export const isFunction = "~lib/builtins/isFunction";

export const isNullable = "~lib/builtins/isNullable";

export const isDefined = "~lib/builtins/isDefined";

export const isConstant = "~lib/builtins/isConstant";

export const isManaged = "~lib/builtins/isManaged";

export const isVoid = "~lib/builtins/isVoid";

export const clz = "~lib/builtins/clz";

export const ctz = "~lib/builtins/ctz";

export const popcnt = "~lib/builtins/popcnt";

export const rotl = "~lib/builtins/rotl";

export const rotr = "~lib/builtins/rotr";

export const abs = "~lib/builtins/abs";

export const max = "~lib/builtins/max";

export const min = "~lib/builtins/min";

export const ceil = "~lib/builtins/ceil";

export const floor = "~lib/builtins/floor";

export const copysign = "~lib/builtins/copysign";

export const nearest = "~lib/builtins/nearest";

export const reinterpret = "~lib/builtins/reinterpret";

export const sqrt = "~lib/builtins/sqrt";

export const trunc = "~lib/builtins/trunc";

export const load = "~lib/builtins/load";

export const store = "~lib/builtins/store";

export const atomic_load = "~lib/builtins/atomic.load";

export const atomic_store = "~lib/builtins/atomic.store";

export const atomic_add = "~lib/builtins/atomic.add";

export const atomic_sub = "~lib/builtins/atomic.sub";

export const atomic_and = "~lib/builtins/atomic.and";

export const atomic_or = "~lib/builtins/atomic.or";

export const atomic_xor = "~lib/builtins/atomic.xor";

export const atomic_xchg = "~lib/builtins/atomic.xchg";

export const atomic_cmpxchg = "~lib/builtins/atomic.cmpxchg";

export const atomic_wait = "~lib/builtins/atomic.wait";

export const atomic_notify = "~lib/builtins/atomic.notify";

export const atomic_fence = "~lib/builtins/atomic.fence";

export const sizeof = "~lib/builtins/sizeof";

export const alignof = "~lib/builtins/alignof";

export const offsetof = "~lib/builtins/offsetof";

export const nameof = "~lib/builtins/nameof";

export const lengthof = "~lib/builtins/lengthof";

export const select = "~lib/builtins/select";

export const unreachable = "~lib/builtins/unreachable";

export const changetype = "~lib/builtins/changetype";

export const assert = "~lib/builtins/assert";

export const unchecked = "~lib/builtins/unchecked";

export const instantiate = "~lib/builtins/instantiate";

export const idof = "~lib/builtins/idof";

export const i8 = "~lib/builtins/i8";

export const i16 = "~lib/builtins/i16";

export const i32 = "~lib/builtins/i32";

export const i64 = "~lib/builtins/i64";

export const isize = "~lib/builtins/isize";

export const u8 = "~lib/builtins/u8";

export const u16 = "~lib/builtins/u16";

export const u32 = "~lib/builtins/u32";

export const u64 = "~lib/builtins/u64";

export const usize = "~lib/builtins/usize";

export const bool = "~lib/builtins/bool";

export const f32 = "~lib/builtins/f32";

export const f64 = "~lib/builtins/f64";

export const v128 = "~lib/builtins/v128";

export const i32_clz = "~lib/builtins/i32.clz";

export const i64_clz = "~lib/builtins/i64.clz";

export const i32_ctz = "~lib/builtins/i32.ctz";

export const i64_ctz = "~lib/builtins/i64.ctz";

export const i32_popcnt = "~lib/builtins/i32.popcnt";

export const i64_popcnt = "~lib/builtins/i64.popcnt";

export const i32_rotl = "~lib/builtins/i32.rotl";

export const i64_rotl = "~lib/builtins/i64.rotl";

export const i32_rotr = "~lib/builtins/i32.rotr";

export const i64_rotr = "~lib/builtins/i64.rotr";

export const f32_abs = "~lib/builtins/f32.abs";

export const f64_abs = "~lib/builtins/f64.abs";

export const f32_max = "~lib/builtins/f32.max";

export const f64_max = "~lib/builtins/f64.max";

export const f32_min = "~lib/builtins/f32.min";

export const f64_min = "~lib/builtins/f64.min";

export const f32_ceil = "~lib/builtins/f32.ceil";

export const f64_ceil = "~lib/builtins/f64.ceil";

export const f32_floor = "~lib/builtins/f32.floor";

export const f64_floor = "~lib/builtins/f64.floor";

export const f32_copysign = "~lib/builtins/f32.copysign";

export const f64_copysign = "~lib/builtins/f64.copysign";

export const f32_nearest = "~lib/builtins/f32.nearest";

export const f64_nearest = "~lib/builtins/f64.nearest";

export const i32_reinterpret_f32 = "~lib/builtins/i32.reinterpret_f32";

export const i64_reinterpret_f64 = "~lib/builtins/i64.reinterpret_f64";

export const f32_reinterpret_i32 = "~lib/builtins/f32.reinterpret_i32";

export const f64_reinterpret_i64 = "~lib/builtins/f64.reinterpret_i64";

export const f32_sqrt = "~lib/builtins/f32.sqrt";

export const f64_sqrt = "~lib/builtins/f64.sqrt";

export const f32_trunc = "~lib/builtins/f32.trunc";

export const f64_trunc = "~lib/builtins/f64.trunc";

export const i32_load8_s = "~lib/builtins/i32.load8_s";

export const i32_load8_u = "~lib/builtins/i32.load8_u";

export const i32_load16_s = "~lib/builtins/i32.load16_s";

export const i32_load16_u = "~lib/builtins/i32.load16_u";

export const i32_load = "~lib/builtins/i32.load";

export const i64_load8_s = "~lib/builtins/i64.load8_s";

export const i64_load8_u = "~lib/builtins/i64.load8_u";

export const i64_load16_s = "~lib/builtins/i64.load16_s";

export const i64_load16_u = "~lib/builtins/i64.load16_u";

export const i64_load32_s = "~lib/builtins/i64.load32_s";

export const i64_load32_u = "~lib/builtins/i64.load32_u";

export const i64_load = "~lib/builtins/i64.load";

export const f32_load = "~lib/builtins/f32.load";

export const f64_load = "~lib/builtins/f64.load";

export const i32_store8 = "~lib/builtins/i32.store8";

export const i32_store16 = "~lib/builtins/i32.store16";

export const i32_store = "~lib/builtins/i32.store";

export const i64_store8 = "~lib/builtins/i64.store8";

export const i64_store16 = "~lib/builtins/i64.store16";

export const i64_store32 = "~lib/builtins/i64.store32";

export const i64_store = "~lib/builtins/i64.store";

export const f32_store = "~lib/builtins/f32.store";

export const f64_store = "~lib/builtins/f64.store";

export const i32_atomic_load8_u = "~lib/builtins/i32.atomic.load8_u";

export const i32_atomic_load16_u = "~lib/builtins/i32.atomic.load16_u";

export const i32_atomic_load = "~lib/builtins/i32.atomic.load";

export const i64_atomic_load8_u = "~lib/builtins/i64.atomic.load8_u";

export const i64_atomic_load16_u = "~lib/builtins/i64.atomic.load16_u";

export const i64_atomic_load32_u = "~lib/builtins/i64.atomic.load32_u";

export const i64_atomic_load = "~lib/builtins/i64.atomic.load";

export const i32_atomic_store8 = "~lib/builtins/i32.atomic.store8";

export const i32_atomic_store16 = "~lib/builtins/i32.atomic.store16";

export const i32_atomic_store = "~lib/builtins/i32.atomic.store";

export const i64_atomic_store8 = "~lib/builtins/i64.atomic.store8";

export const i64_atomic_store16 = "~lib/builtins/i64.atomic.store16";

export const i64_atomic_store32 = "~lib/builtins/i64.atomic.store32";

export const i64_atomic_store = "~lib/builtins/i64.atomic.store";

export const i32_atomic_rmw8_add_u = "~lib/builtins/i32.atomic.rmw8.add_u";

export const i32_atomic_rmw16_add_u = "~lib/builtins/i32.atomic.rmw16.add_u";

export const i32_atomic_rmw_add = "~lib/builtins/i32.atomic.rmw.add";

export const i64_atomic_rmw8_add_u = "~lib/builtins/i64.atomic.rmw8.add_u";

export const i64_atomic_rmw16_add_u = "~lib/builtins/i64.atomic.rmw16.add_u";

export const i64_atomic_rmw32_add_u = "~lib/builtins/i64.atomic.rmw32.add_u";

export const i64_atomic_rmw_add = "~lib/builtins/i64.atomic.rmw.add";

export const i32_atomic_rmw8_sub_u = "~lib/builtins/i32.atomic.rmw8.sub_u";

export const i32_atomic_rmw16_sub_u = "~lib/builtins/i32.atomic.rmw16.sub_u";

export const i32_atomic_rmw_sub = "~lib/builtins/i32.atomic.rmw.sub";

export const i64_atomic_rmw8_sub_u = "~lib/builtins/i64.atomic.rmw8.sub_u";

export const i64_atomic_rmw16_sub_u = "~lib/builtins/i64.atomic.rmw16.sub_u";

export const i64_atomic_rmw32_sub_u = "~lib/builtins/i64.atomic.rmw32.sub_u";

export const i64_atomic_rmw_sub = "~lib/builtins/i64.atomic.rmw.sub";

export const i32_atomic_rmw8_and_u = "~lib/builtins/i32.atomic.rmw8.and_u";

export const i32_atomic_rmw16_and_u = "~lib/builtins/i32.atomic.rmw16.and_u";

export const i32_atomic_rmw_and = "~lib/builtins/i32.atomic.rmw.and";

export const i64_atomic_rmw8_and_u = "~lib/builtins/i64.atomic.rmw8.and_u";

export const i64_atomic_rmw16_and_u = "~lib/builtins/i64.atomic.rmw16.and_u";

export const i64_atomic_rmw32_and_u = "~lib/builtins/i64.atomic.rmw32.and_u";

export const i64_atomic_rmw_and = "~lib/builtins/i64.atomic.rmw.and";

export const i32_atomic_rmw8_or_u = "~lib/builtins/i32.atomic.rmw8.or_u";

export const i32_atomic_rmw16_or_u = "~lib/builtins/i32.atomic.rmw16.or_u";

export const i32_atomic_rmw_or = "~lib/builtins/i32.atomic.rmw.or";

export const i64_atomic_rmw8_or_u = "~lib/builtins/i64.atomic.rmw8.or_u";

export const i64_atomic_rmw16_or_u = "~lib/builtins/i64.atomic.rmw16.or_u";

export const i64_atomic_rmw32_or_u = "~lib/builtins/i64.atomic.rmw32.or_u";

export const i64_atomic_rmw_or = "~lib/builtins/i64.atomic.rmw.or";

export const i32_atomic_rmw8_xor_u = "~lib/builtins/i32.atomic.rmw8.xor_u";

export const i32_atomic_rmw16_xor_u = "~lib/builtins/i32.atomic.rmw16.xor_u";

export const i32_atomic_rmw_xor = "~lib/builtins/i32.atomic.rmw.xor";

export const i64_atomic_rmw8_xor_u = "~lib/builtins/i64.atomic.rmw8.xor_u";

export const i64_atomic_rmw16_xor_u = "~lib/builtins/i64.atomic.rmw16.xor_u";

export const i64_atomic_rmw32_xor_u = "~lib/builtins/i64.atomic.rmw32.xor_u";

export const i64_atomic_rmw_xor = "~lib/builtins/i64.atomic.rmw.xor";

export const i32_atomic_rmw8_xchg_u = "~lib/builtins/i32.atomic.rmw8.xchg_u";

export const i32_atomic_rmw16_xchg_u = "~lib/builtins/i32.atomic.rmw16.xchg_u";

export const i32_atomic_rmw_xchg = "~lib/builtins/i32.atomic.rmw.xchg";

export const i64_atomic_rmw8_xchg_u = "~lib/builtins/i64.atomic.rmw8.xchg_u";

export const i64_atomic_rmw16_xchg_u = "~lib/builtins/i64.atomic.rmw16.xchg_u";

export const i64_atomic_rmw32_xchg_u = "~lib/builtins/i64.atomic.rmw32.xchg_u";

export const i64_atomic_rmw_xchg = "~lib/builtins/i64.atomic.rmw.xchg";

export const i32_atomic_rmw8_cmpxchg_u = "~lib/builtins/i32.atomic.rmw8.cmpxchg_u";

export const i32_atomic_rmw16_cmpxchg_u = "~lib/builtins/i32.atomic.rmw16.cmpxchg_u";

export const i32_atomic_rmw_cmpxchg = "~lib/builtins/i32.atomic.rmw.cmpxchg";

export const i64_atomic_rmw8_cmpxchg_u = "~lib/builtins/i64.atomic.rmw8.cmpxchg_u";

export const i64_atomic_rmw16_cmpxchg_u = "~lib/builtins/i64.atomic.rmw16.cmpxchg_u";

export const i64_atomic_rmw32_cmpxchg_u = "~lib/builtins/i64.atomic.rmw32.cmpxchg_u";

export const i64_atomic_rmw_cmpxchg = "~lib/builtins/i64.atomic.rmw.cmpxchg";

export const i32_wait = "~lib/builtins/i32.wait";

export const i64_wait = "~lib/builtins/i64.wait";

export const v128_splat = "~lib/builtins/v128.splat";

export const v128_extract_lane = "~lib/builtins/v128.extract_lane";

export const v128_replace_lane = "~lib/builtins/v128.replace_lane";

export const v128_shuffle = "~lib/builtins/v128.shuffle";

export const v128_swizzle = "~lib/builtins/v128.swizzle";

export const v128_load_splat = "~lib/builtins/v128.load_splat";

export const v128_load_ext = "~lib/builtins/v128.load_ext";

export const v128_load = "~lib/builtins/v128.load";

export const v128_store = "~lib/builtins/v128.store";

export const v128_add = "~lib/builtins/v128.add";

export const v128_sub = "~lib/builtins/v128.sub";

export const v128_mul = "~lib/builtins/v128.mul";

export const v128_div = "~lib/builtins/v128.div";

export const v128_neg = "~lib/builtins/v128.neg";

export const v128_add_saturate = "~lib/builtins/v128.add_saturate";

export const v128_sub_saturate = "~lib/builtins/v128.sub_saturate";

export const v128_shl = "~lib/builtins/v128.shl";

export const v128_shr = "~lib/builtins/v128.shr";

export const v128_and = "~lib/builtins/v128.and";

export const v128_or = "~lib/builtins/v128.or";

export const v128_xor = "~lib/builtins/v128.xor";

export const v128_andnot = "~lib/builtins/v128.andnot";

export const v128_not = "~lib/builtins/v128.not";

export const v128_bitselect = "~lib/builtins/v128.bitselect";

export const v128_any_true = "~lib/builtins/v128.any_true";

export const v128_all_true = "~lib/builtins/v128.all_true";

export const v128_bitmask = "~lib/builtins/v128.bitmask";

export const v128_min = "~lib/builtins/v128.min";

export const v128_max = "~lib/builtins/v128.max";

export const v128_pmin = "~lib/builtins/v128.pmin";

export const v128_pmax = "~lib/builtins/v128.pmax";

export const v128_dot = "~lib/builtins/v128.dot";

export const v128_avgr = "~lib/builtins/v128.avgr";

export const v128_abs = "~lib/builtins/v128.abs";

export const v128_sqrt = "~lib/builtins/v128.sqrt";

export const v128_ceil = "~lib/builtins/v128.ceil";

export const v128_floor = "~lib/builtins/v128.floor";

export const v128_trunc = "~lib/builtins/v128.trunc";

export const v128_nearest = "~lib/builtins/v128.nearest";

export const v128_eq = "~lib/builtins/v128.eq";

export const v128_ne = "~lib/builtins/v128.ne";

export const v128_lt = "~lib/builtins/v128.lt";

export const v128_le = "~lib/builtins/v128.le";

export const v128_gt = "~lib/builtins/v128.gt";

export const v128_ge = "~lib/builtins/v128.ge";

export const v128_convert = "~lib/builtins/v128.convert";

export const v128_trunc_sat = "~lib/builtins/v128.trunc_sat";

export const v128_narrow = "~lib/builtins/v128.narrow";

export const v128_widen_low = "~lib/builtins/v128.widen_low";

export const v128_widen_high = "~lib/builtins/v128.widen_high";

export const v128_qfma = "~lib/builtins/v128.qfma";

export const v128_qfms = "~lib/builtins/v128.qfms";

export const i8x16 = "~lib/builtins/i8x16";

export const i16x8 = "~lib/builtins/i16x8";

export const i32x4 = "~lib/builtins/i32x4";

export const i64x2 = "~lib/builtins/i64x2";

export const f32x4 = "~lib/builtins/f32x4";

export const f64x2 = "~lib/builtins/f64x2";

export const i8x16_splat = "~lib/builtins/i8x16.splat";

export const i8x16_extract_lane_s = "~lib/builtins/i8x16.extract_lane_s";

export const i8x16_extract_lane_u = "~lib/builtins/i8x16.extract_lane_u";

export const i8x16_replace_lane = "~lib/builtins/i8x16.replace_lane";

export const i8x16_add = "~lib/builtins/i8x16.add";

export const i8x16_sub = "~lib/builtins/i8x16.sub";

export const i8x16_mul = "~lib/builtins/i8x16.mul";

export const i8x16_min_s = "~lib/builtins/i8x16.min_s";

export const i8x16_min_u = "~lib/builtins/i8x16.min_u";

export const i8x16_max_s = "~lib/builtins/i8x16.max_s";

export const i8x16_max_u = "~lib/builtins/i8x16.max_u";

export const i8x16_avgr_u = "~lib/builtins/i8x16.avgr_u";

export const i8x16_abs = "~lib/builtins/i8x16.abs";

export const i8x16_neg = "~lib/builtins/i8x16.neg";

export const i8x16_add_saturate_s = "~lib/builtins/i8x16.add_saturate_s";

export const i8x16_add_saturate_u = "~lib/builtins/i8x16.add_saturate_u";

export const i8x16_sub_saturate_s = "~lib/builtins/i8x16.sub_saturate_s";

export const i8x16_sub_saturate_u = "~lib/builtins/i8x16.sub_saturate_u";

export const i8x16_shl = "~lib/builtins/i8x16.shl";

export const i8x16_shr_s = "~lib/builtins/i8x16.shr_s";

export const i8x16_shr_u = "~lib/builtins/i8x16.shr_u";

export const i8x16_any_true = "~lib/builtins/i8x16.any_true";

export const i8x16_all_true = "~lib/builtins/i8x16.all_true";

export const i8x16_bitmask = "~lib/builtins/i8x16.bitmask";

export const i8x16_eq = "~lib/builtins/i8x16.eq";

export const i8x16_ne = "~lib/builtins/i8x16.ne";

export const i8x16_lt_s = "~lib/builtins/i8x16.lt_s";

export const i8x16_lt_u = "~lib/builtins/i8x16.lt_u";

export const i8x16_le_s = "~lib/builtins/i8x16.le_s";

export const i8x16_le_u = "~lib/builtins/i8x16.le_u";

export const i8x16_gt_s = "~lib/builtins/i8x16.gt_s";

export const i8x16_gt_u = "~lib/builtins/i8x16.gt_u";

export const i8x16_ge_s = "~lib/builtins/i8x16.ge_s";

export const i8x16_ge_u = "~lib/builtins/i8x16.ge_u";

export const i8x16_narrow_i16x8_s = "~lib/builtins/i8x16.narrow_i16x8_s";

export const i8x16_narrow_i16x8_u = "~lib/builtins/i8x16.narrow_i16x8_u";

export const i16x8_splat = "~lib/builtins/i16x8.splat";

export const i16x8_extract_lane_s = "~lib/builtins/i16x8.extract_lane_s";

export const i16x8_extract_lane_u = "~lib/builtins/i16x8.extract_lane_u";

export const i16x8_replace_lane = "~lib/builtins/i16x8.replace_lane";

export const i16x8_add = "~lib/builtins/i16x8.add";

export const i16x8_sub = "~lib/builtins/i16x8.sub";

export const i16x8_mul = "~lib/builtins/i16x8.mul";

export const i16x8_min_s = "~lib/builtins/i16x8.min_s";

export const i16x8_min_u = "~lib/builtins/i16x8.min_u";

export const i16x8_max_s = "~lib/builtins/i16x8.max_s";

export const i16x8_max_u = "~lib/builtins/i16x8.max_u";

export const i16x8_avgr_u = "~lib/builtins/i16x8.avgr_u";

export const i16x8_abs = "~lib/builtins/i16x8.abs";

export const i16x8_neg = "~lib/builtins/i16x8.neg";

export const i16x8_add_saturate_s = "~lib/builtins/i16x8.add_saturate_s";

export const i16x8_add_saturate_u = "~lib/builtins/i16x8.add_saturate_u";

export const i16x8_sub_saturate_s = "~lib/builtins/i16x8.sub_saturate_s";

export const i16x8_sub_saturate_u = "~lib/builtins/i16x8.sub_saturate_u";

export const i16x8_shl = "~lib/builtins/i16x8.shl";

export const i16x8_shr_s = "~lib/builtins/i16x8.shr_s";

export const i16x8_shr_u = "~lib/builtins/i16x8.shr_u";

export const i16x8_any_true = "~lib/builtins/i16x8.any_true";

export const i16x8_all_true = "~lib/builtins/i16x8.all_true";

export const i16x8_bitmask = "~lib/builtins/i16x8.bitmask";

export const i16x8_eq = "~lib/builtins/i16x8.eq";

export const i16x8_ne = "~lib/builtins/i16x8.ne";

export const i16x8_lt_s = "~lib/builtins/i16x8.lt_s";

export const i16x8_lt_u = "~lib/builtins/i16x8.lt_u";

export const i16x8_le_s = "~lib/builtins/i16x8.le_s";

export const i16x8_le_u = "~lib/builtins/i16x8.le_u";

export const i16x8_gt_s = "~lib/builtins/i16x8.gt_s";

export const i16x8_gt_u = "~lib/builtins/i16x8.gt_u";

export const i16x8_ge_s = "~lib/builtins/i16x8.ge_s";

export const i16x8_ge_u = "~lib/builtins/i16x8.ge_u";

export const i16x8_narrow_i32x4_s = "~lib/builtins/i16x8.narrow_i32x4_s";

export const i16x8_narrow_i32x4_u = "~lib/builtins/i16x8.narrow_i32x4_u";

export const i16x8_widen_low_i8x16_s = "~lib/builtins/i16x8.widen_low_i8x16_s";

export const i16x8_widen_low_i8x16_u = "~lib/builtins/i16x8.widen_low_i8x16_u";

export const i16x8_widen_high_i8x16_s = "~lib/builtins/i16x8.widen_high_i8x16_s";

export const i16x8_widen_high_i8x16_u = "~lib/builtins/i16x8.widen_high_i8x16_u";

export const i16x8_load8x8_s = "~lib/builtins/i16x8.load8x8_s";

export const i16x8_load8x8_u = "~lib/builtins/i16x8.load8x8_u";

export const i32x4_splat = "~lib/builtins/i32x4.splat";

export const i32x4_extract_lane = "~lib/builtins/i32x4.extract_lane";

export const i32x4_replace_lane = "~lib/builtins/i32x4.replace_lane";

export const i32x4_add = "~lib/builtins/i32x4.add";

export const i32x4_sub = "~lib/builtins/i32x4.sub";

export const i32x4_mul = "~lib/builtins/i32x4.mul";

export const i32x4_min_s = "~lib/builtins/i32x4.min_s";

export const i32x4_min_u = "~lib/builtins/i32x4.min_u";

export const i32x4_max_s = "~lib/builtins/i32x4.max_s";

export const i32x4_max_u = "~lib/builtins/i32x4.max_u";

export const i32x4_dot_i16x8_s = "~lib/builtins/i32x4.dot_i16x8_s";

export const i32x4_abs = "~lib/builtins/i32x4.abs";

export const i32x4_neg = "~lib/builtins/i32x4.neg";

export const i32x4_shl = "~lib/builtins/i32x4.shl";

export const i32x4_shr_s = "~lib/builtins/i32x4.shr_s";

export const i32x4_shr_u = "~lib/builtins/i32x4.shr_u";

export const i32x4_any_true = "~lib/builtins/i32x4.any_true";

export const i32x4_all_true = "~lib/builtins/i32x4.all_true";

export const i32x4_bitmask = "~lib/builtins/i32x4.bitmask";

export const i32x4_eq = "~lib/builtins/i32x4.eq";

export const i32x4_ne = "~lib/builtins/i32x4.ne";

export const i32x4_lt_s = "~lib/builtins/i32x4.lt_s";

export const i32x4_lt_u = "~lib/builtins/i32x4.lt_u";

export const i32x4_le_s = "~lib/builtins/i32x4.le_s";

export const i32x4_le_u = "~lib/builtins/i32x4.le_u";

export const i32x4_gt_s = "~lib/builtins/i32x4.gt_s";

export const i32x4_gt_u = "~lib/builtins/i32x4.gt_u";

export const i32x4_ge_s = "~lib/builtins/i32x4.ge_s";

export const i32x4_ge_u = "~lib/builtins/i32x4.ge_u";

export const i32x4_trunc_sat_f32x4_s = "~lib/builtins/i32x4.trunc_sat_f32x4_s";

export const i32x4_trunc_sat_f32x4_u = "~lib/builtins/i32x4.trunc_sat_f32x4_u";

export const i32x4_widen_low_i16x8_s = "~lib/builtins/i32x4.widen_low_i16x8_s";

export const i32x4_widen_low_i16x8_u = "~lib/builtins/i32x4.widen_low_i16x8_u";

export const i32x4_widen_high_i16x8_s = "~lib/builtins/i32x4.widen_high_i16x8_s";

export const i32x4_widen_high_i16x8_u = "~lib/builtins/i32x4.widen_high_i16x8_u";

export const i32x4_load16x4_s = "~lib/builtins/i32x4.load16x4_s";

export const i32x4_load16x4_u = "~lib/builtins/i32x4.load16x4_u";

export const i64x2_splat = "~lib/builtins/i64x2.splat";

export const i64x2_extract_lane = "~lib/builtins/i64x2.extract_lane";

export const i64x2_replace_lane = "~lib/builtins/i64x2.replace_lane";

export const i64x2_add = "~lib/builtins/i64x2.add";

export const i64x2_sub = "~lib/builtins/i64x2.sub"; // i64x2 has no .mul

export const i64x2_neg = "~lib/builtins/i64x2.neg";

export const i64x2_shl = "~lib/builtins/i64x2.shl";

export const i64x2_shr_s = "~lib/builtins/i64x2.shr_s";

export const i64x2_shr_u = "~lib/builtins/i64x2.shr_u";

export const i64x2_any_true = "~lib/builtins/i64x2.any_true";

export const i64x2_all_true = "~lib/builtins/i64x2.all_true"; // i64x2 has no .eq etc.

export const i64x2_trunc_sat_f64x2_s = "~lib/builtins/i64x2.trunc_sat_f64x2_s";

export const i64x2_trunc_sat_f64x2_u = "~lib/builtins/i64x2.trunc_sat_f64x2_u";

export const i64x2_load32x2_s = "~lib/builtins/i64x2.load32x2_s";

export const i64x2_load32x2_u = "~lib/builtins/i64x2.load32x2_u";

export const f32x4_splat = "~lib/builtins/f32x4.splat";

export const f32x4_extract_lane = "~lib/builtins/f32x4.extract_lane";

export const f32x4_replace_lane = "~lib/builtins/f32x4.replace_lane";

export const f32x4_add = "~lib/builtins/f32x4.add";

export const f32x4_sub = "~lib/builtins/f32x4.sub";

export const f32x4_mul = "~lib/builtins/f32x4.mul";

export const f32x4_div = "~lib/builtins/f32x4.div";

export const f32x4_neg = "~lib/builtins/f32x4.neg";

export const f32x4_min = "~lib/builtins/f32x4.min";

export const f32x4_max = "~lib/builtins/f32x4.max";

export const f32x4_pmin = "~lib/builtins/f32x4.pmin";

export const f32x4_pmax = "~lib/builtins/f32x4.pmax";

export const f32x4_abs = "~lib/builtins/f32x4.abs";

export const f32x4_sqrt = "~lib/builtins/f32x4.sqrt";

export const f32x4_ceil = "~lib/builtins/f32x4.ceil";

export const f32x4_floor = "~lib/builtins/f32x4.floor";

export const f32x4_trunc = "~lib/builtins/f32x4.trunc";

export const f32x4_nearest = "~lib/builtins/f32x4.nearest";

export const f32x4_eq = "~lib/builtins/f32x4.eq";

export const f32x4_ne = "~lib/builtins/f32x4.ne";

export const f32x4_lt = "~lib/builtins/f32x4.lt";

export const f32x4_le = "~lib/builtins/f32x4.le";

export const f32x4_gt = "~lib/builtins/f32x4.gt";

export const f32x4_ge = "~lib/builtins/f32x4.ge";

export const f32x4_convert_i32x4_s = "~lib/builtins/f32x4.convert_i32x4_s";

export const f32x4_convert_i32x4_u = "~lib/builtins/f32x4.convert_i32x4_u";

export const f32x4_qfma = "~lib/builtins/f32x4.qfma";

export const f32x4_qfms = "~lib/builtins/f32x4.qfms";

export const f64x2_splat = "~lib/builtins/f64x2.splat";

export const f64x2_extract_lane = "~lib/builtins/f64x2.extract_lane";

export const f64x2_replace_lane = "~lib/builtins/f64x2.replace_lane";

export const f64x2_add = "~lib/builtins/f64x2.add";

export const f64x2_sub = "~lib/builtins/f64x2.sub";

export const f64x2_mul = "~lib/builtins/f64x2.mul";

export const f64x2_div = "~lib/builtins/f64x2.div";

export const f64x2_neg = "~lib/builtins/f64x2.neg";

export const f64x2_min = "~lib/builtins/f64x2.min";

export const f64x2_max = "~lib/builtins/f64x2.max";

export const f64x2_pmin = "~lib/builtins/f64x2.pmin";

export const f64x2_pmax = "~lib/builtins/f64x2.pmax";

export const f64x2_abs = "~lib/builtins/f64x2.abs";

export const f64x2_sqrt = "~lib/builtins/f64x2.sqrt";

export const f64x2_ceil = "~lib/builtins/f64x2.ceil";

export const f64x2_floor = "~lib/builtins/f64x2.floor";

export const f64x2_trunc = "~lib/builtins/f64x2.trunc";

export const f64x2_nearest = "~lib/builtins/f64x2.nearest";

export const f64x2_eq = "~lib/builtins/f64x2.eq";

export const f64x2_ne = "~lib/builtins/f64x2.ne";

export const f64x2_lt = "~lib/builtins/f64x2.lt";

export const f64x2_le = "~lib/builtins/f64x2.le";

export const f64x2_gt = "~lib/builtins/f64x2.gt";

export const f64x2_ge = "~lib/builtins/f64x2.ge";

export const f64x2_convert_i64x2_s = "~lib/builtins/f64x2.convert_i64x2_s";

export const f64x2_convert_i64x2_u = "~lib/builtins/f64x2.convert_i64x2_u";

export const f64x2_qfma = "~lib/builtins/f64x2.qfma";

export const f64x2_qfms = "~lib/builtins/f64x2.qfms";

export const v8x16_shuffle = "~lib/builtins/v8x16.shuffle";

export const v8x16_swizzle = "~lib/builtins/v8x16.swizzle";

export const v8x16_load_splat = "~lib/builtins/v8x16.load_splat";

export const v16x8_load_splat = "~lib/builtins/v16x8.load_splat";

export const v32x4_load_splat = "~lib/builtins/v32x4.load_splat";

export const v64x2_load_splat = "~lib/builtins/v64x2.load_splat";

// internals

export const heap_base = "~lib/heap/__heap_base";

export const rtti_base = "~lib/rt/__rtti_base";

export const visit_globals = "~lib/rt/__visit_globals";

export const visit_members = "~lib/rt/__visit_members";

// std/number.ts

export const isNaN = "~lib/number/isNaN";

export const isFinite = "~lib/number/isFinite";

// std/diagnostics.ts

export const ERROR = "~lib/diagnostics/ERROR";

export const WARNING = "~lib/diagnostics/WARNING";

export const INFO = "~lib/diagnostics/INFO";

// std/memory.ts

export const memory_size = "~lib/memory/memory.size";

export const memory_grow = "~lib/memory/memory.grow";

export const memory_copy = "~lib/memory/memory.copy";

export const memory_fill = "~lib/memory/memory.fill";

export const memory_data = "~lib/memory/memory.data";

// std/typedarray.ts

export const Int8Array = "~lib/typedarray/Int8Array";

export const Uint8Array = "~lib/typedarray/Uint8Array";

export const Uint8ClampedArray = "~lib/typedarray/Uint8ClampedArray";

export const Int16Array = "~lib/typedarray/Int16Array";

export const Uint16Array = "~lib/typedarray/Uint16Array";

export const Int32Array = "~lib/typedarray/Int32Array";

export const Uint32Array = "~lib/typedarray/Uint32Array";

export const Int64Array = "~lib/typedarray/Int64Array";

export const Uint64Array = "~lib/typedarray/Uint64Array";

export const Float32Array = "~lib/typedarray/Float32Array";

export const Float64Array = "~lib/typedarray/Float64Array";

// std/bindings/wasi.ts

export const wasiAbort = "~lib/wasi/index/abort";

export const wasiTrace = "~lib/wasi/index/trace";

export const wasiSeed = "~lib/wasi/index/seed";

}

/** Builtin compilation context. */

export class BuiltinContext {

constructor(

/** Compiler reference. */

public compiler: Compiler,

/** Prototype being called. */

public prototype: FunctionPrototype,

/** Provided type arguments. */

public typeArguments: Type[] | null,

/** Provided operands. */

public operands: Expression[],

/** Contextual type. */

public contextualType: Type,

/** Respective call expression. */

public reportNode: CallExpression,

/** Whether originating from inline assembly. */

public contextIsExact: bool

) {}

}

/** Global builtins map. */

export const builtins = new Map<string,(ctx: BuiltinContext) => ExpressionRef>();

// === Static type evaluation =================================================================

// isInteger<T!>() / isInteger<T?>(value: T) -> bool

function builtin_isInteger(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.is(TypeFlags.INTEGER) && !type.is(TypeFlags.REFERENCE) ? 1 : 0);

}

builtins.set(BuiltinNames.isInteger, builtin_isInteger);

// isFloat<T!>() / isFloat<T?>(value: T) -> bool

function builtin_isFloat(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.is(TypeFlags.FLOAT) ? 1 : 0);

}

builtins.set(BuiltinNames.isFloat, builtin_isFloat);

// isBoolean<T!>() / isBoolean<T?>(value: T) -> bool

function builtin_isBoolean(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type == Type.bool ? 1 : 0);

}

builtins.set(BuiltinNames.isBoolean, builtin_isBoolean);

// isSigned<T!>() / isSigned<T?>(value: T) -> bool

function builtin_isSigned(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.is(TypeFlags.SIGNED) ? 1 : 0);

}

builtins.set(BuiltinNames.isSigned, builtin_isSigned);

// isReference<T!>() / isReference<T?>(value: T) -> bool

function builtin_isReference(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.is(TypeFlags.REFERENCE) ? 1 : 0);

}

builtins.set(BuiltinNames.isReference, builtin_isReference);

// isString<T!>() / isString<T?>(value: T) -> bool

function builtin_isString(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

if (type.is(TypeFlags.REFERENCE)) {

let classReference = type.classReference;

if (classReference) {

let stringInstance = compiler.program.stringInstance;

if (stringInstance !== null && classReference.isAssignableTo(stringInstance)) return module.i32(1);

}

}

return module.i32(0);

}

builtins.set(BuiltinNames.isString, builtin_isString);

// isArray<T!>() / isArray<T?>(value: T) -> bool

function builtin_isArray(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

if (type.is(TypeFlags.REFERENCE)) {

let classReference = type.classReference;

if (classReference) {

return module.i32(classReference.prototype.extends(compiler.program.arrayPrototype) ? 1 : 0);

}

}

return module.i32(0);

}

builtins.set(BuiltinNames.isArray, builtin_isArray);

// isArrayLike<T!>() / isArrayLike<T?>(value: T) -> bool

function builtin_isArrayLike(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

if (type.is(TypeFlags.REFERENCE)) {

let classReference = type.classReference;

if (classReference) {

return module.i32(classReference.isArrayLike ? 1 : 0);

}

}

return module.i32(0);

}

builtins.set(BuiltinNames.isArrayLike, builtin_isArrayLike);

// isFunction<T!> / isFunction<T?>(value: T) -> bool

function builtin_isFunction(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.signatureReference ? 1 : 0);

}

builtins.set(BuiltinNames.isFunction, builtin_isFunction);

// isNullable<T!> / isNullable<T?>(value: T) -> bool

function builtin_isNullable(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.is(TypeFlags.NULLABLE) ? 1 : 0);

}

builtins.set(BuiltinNames.isNullable, builtin_isNullable);

// isDefined(expression) -> bool

function builtin_isDefined(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

compiler.currentType = Type.bool;

if (

checkTypeAbsent(ctx) |

checkArgsRequired(ctx, 1)

) return module.unreachable();

var element = compiler.resolver.lookupExpression(

ctx.operands[0],

compiler.currentFlow,

Type.auto,

ReportMode.SWALLOW

);

return module.i32(element ? 1 : 0);

}

builtins.set(BuiltinNames.isDefined, builtin_isDefined);

// isConstant(expression) -> bool

function builtin_isConstant(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

compiler.currentType = Type.bool;

if (

checkTypeAbsent(ctx) |

checkArgsRequired(ctx, 1)

) return module.unreachable();

var expr = compiler.compileExpression(ctx.operands[0], Type.auto);

compiler.currentType = Type.bool;

return module.i32(getExpressionId(expr) == ExpressionId.Const ? 1 : 0);

}

builtins.set(BuiltinNames.isConstant, builtin_isConstant);

// isManaged<T!>() -> bool

function builtin_isManaged(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.isManaged ? 1 : 0);

}

builtins.set(BuiltinNames.isManaged, builtin_isManaged);

// isVoid<T!>() -> bool

function builtin_isVoid(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.kind == TypeKind.VOID ? 1 : 0);

}

builtins.set(BuiltinNames.isVoid, builtin_isVoid);

// lengthof<T!>() -> i32

function builtin_lengthof(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var type = evaluateConstantType(ctx);

compiler.currentType = Type.i32;

if (!type) return module.unreachable();

var signatureReference = type.signatureReference;

if (!signatureReference) {

compiler.error(

DiagnosticCode.Type_0_has_no_call_signatures,

ctx.reportNode.range, type.toString()

);

return module.unreachable();

}

return module.i32(signatureReference.parameterTypes.length);

}

builtins.set(BuiltinNames.lengthof, builtin_lengthof);

// sizeof<T!>() -> usize*

function builtin_sizeof(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

compiler.currentType = compiler.options.usizeType;

if (

checkTypeRequired(ctx) |

checkArgsRequired(ctx, 0)

) return module.unreachable();

var type = ctx.typeArguments![0];

var byteSize = type.byteSize;

if (!byteSize) {

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

ctx.reportNode.typeArgumentsRange, "sizeof", type.toString()

);

return module.unreachable();

}

return contextualUsize(compiler, i64_new(byteSize), ctx.contextualType);

}

builtins.set(BuiltinNames.sizeof, builtin_sizeof);

// alignof<T!>() -> usize*

function builtin_alignof(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

compiler.currentType = compiler.options.usizeType;

if (

checkTypeRequired(ctx) |

checkArgsRequired(ctx, 0)

) return module.unreachable();

var type = ctx.typeArguments![0];

var byteSize = type.byteSize;

if (!isPowerOf2(byteSize)) { // implies == 0

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

ctx.reportNode.typeArgumentsRange, "alignof", type.toString()

);

return module.unreachable();

}

return contextualUsize(compiler, i64_new(ctz<i32>(byteSize)), ctx.contextualType);

}

builtins.set(BuiltinNames.alignof, builtin_alignof);

// offsetof<T!>(fieldName?: string) -> usize*

function builtin_offsetof(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

compiler.currentType = compiler.options.usizeType;

if (

checkTypeRequired(ctx) |

checkArgsOptional(ctx, 0, 1)

) return module.unreachable();

var operands = ctx.operands;

var contextualType = ctx.contextualType;

var type = ctx.typeArguments![0];

var classType = type.classReference;

if (!(type.is(TypeFlags.REFERENCE) && classType !== null)) {

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

ctx.reportNode.typeArgumentsRange, "offsetof", type.toString()

);

if (compiler.options.isWasm64) {

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size <= 32) {

compiler.currentType = Type.u32;

}

} else {

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size == 64) {

compiler.currentType = Type.u64;

}

}

return module.unreachable();

}

if (operands.length) {

let firstOperand = operands[0];

if (!firstOperand.isLiteralKind(LiteralKind.STRING)) {

compiler.error(

DiagnosticCode.String_literal_expected,

operands[0].range

);

return module.unreachable();

}

let fieldName = (<StringLiteralExpression>firstOperand).value;

let classMembers = classType.members;

if (classMembers !== null && classMembers.has(fieldName)) {

let member = assert(classMembers.get(fieldName));

if (member.kind == ElementKind.FIELD) {

return contextualUsize(compiler, i64_new((<Field>member).memoryOffset), contextualType);

}

}

compiler.error(

DiagnosticCode.Type_0_has_no_property_1,

firstOperand.range, classType.internalName, fieldName

);

return module.unreachable();

}

return contextualUsize(compiler, i64_new(classType.nextMemoryOffset), contextualType);

}

builtins.set(BuiltinNames.offsetof, builtin_offsetof);

// nameof<T> -> string

function builtin_nameof(ctx: BuiltinContext): ExpressionRef {

var compiler = ctx.compiler;

var module = compiler.module;

var resultType = evaluateConstantType(ctx);

if (!resultType) {

compiler.currentType = compiler.program.stringInstance.type;

return module.unreachable();

}

var value: string;

if (resultType.is(TypeFlags.REFERENCE)) {

let classReference = resultType.classReference;

if (classReference) {

value = classReference.name;

} else {

let signatureReference = resultType.signatureReference;

if (signatureReference) {

value = "Function";

} else {

value = "Anyref";

}

}

} else {

switch (resultType.kind) {

case TypeKind.BOOL: { value = "bool"; break; }

case TypeKind.I8: { value = "i8"; break; }

case TypeKind.U8: { value = "u8"; break; }

case TypeKind.I16: { value = "i16"; break; }

case TypeKind.U16: { value = "u16"; break; }

case TypeKind.I32: { value = "i32"; break; }

case TypeKind.U32: { value = "u32"; break; }

case TypeKind.F32: { value = "f32"; break; }

case TypeKind.I64: { value = "i64"; break; }

case TypeKind.U64: { value = "u64"; break; }

case TypeKind.F64: { value = "f64"; break; }

case TypeKind.ISIZE: { value = "isize"; break; }

case TypeKind.USIZE: { value = "usize"; break; }

case TypeKind.V128: { value = "v128"; break; }

case TypeKind.ANYREF: { value = "anyref"; break; }

default: assert(false);

case TypeKind.VOID: { value = "void"; break; }

}

}

return compiler.ensureStaticString(value);

}

builtins.set(BuiltinNames.nameof, builtin_nameof);