Types

WebAssembly’s value types, spelled like TypeScript.

Basic types

• No implicit narrowing. Convert explicitly with as: x as u8, f as i32. Float-to-int truncates and traps out of range (upstream AssemblyScript saturates).
• Integer literals type contextually: a literal takes the type its context asks for when it fits, otherwise i32, u32, i64 or, past i64’s range, u64, so 18446744073709551615 > 1 holds. A literal that cannot fit a small type, or a negative one past i64’s range, is an error rather than a wrap.
• Orderings (<, >, <=, >=) compare values across signedness, as TypeScript numbers do: x > -1 holds for every u32 x. A signed and an unsigned operand widen to a signed type that holds both, i64 for 32 bit ones, and a u64 against a signed value tests the sign first. A constant expression, unlike a bare literal, takes a 32 or 64 bit operand's type as in upstream AssemblyScript, so x > 0 - 1 is false, and equality converts to one operand's type, so an i32 -1 equals the u32 4294967295.
• Integer division and remainder by zero trap.
• No any, no undefined, no union types; a nullable reference is written T?.
• A line break ends a type before [, as in TypeScript, so a [ starting the next line begins a new statement rather than an array type: let o = x as Cell followed by a line [1, 2].forEach(…) casts and then runs the call.

Small integers

WebAssembly has no 8 or 16 bit values. Locals, parameters, returns and the operand stack hold only 32 and 64 bit integers and floats, so an i8, u8, i16 or u16 is a wasm i32 everywhere except memory. Memory is the one place with real 8 and 16 bit values: loads and stores of those widths read and write exactly one or two bytes.

The results still behave like true small integers, as in upstream AssemblyScript. Arithmetic runs at 32 bits and may leave extra high bits, and every use that could see them narrows first: comparisons, division, remainder, right shifts, **, conversions to other types, conditions, returns, switch, and the integer builtins abs, clz, ctz, popcnt, min and max. rotl and rotr rotate within the small width, and constant folding follows the same rule. The narrowing is one extra instruction, a small cost in a tight loop that compares or divides small integers. Addition, subtraction, multiplication, &, |, ^ and << never need it.

declare function print(s: string): void;

class Pixel { r: u8 = 0; g: u8 = 0; }

export function demo(): void {
    let x: u8 = 255;
    x++;
    print(x.toString());                   // 0, as in C and asc

    let p = new Pixel();
    p.r = 200;
    p.g = 200;
    print(((p.r + p.g) >> 1).toString()); // 72, a u8 sum wraps before >>

    // Compute in i32: no overflow and nothing to narrow.
    let r: i32 = p.r;
    let g: i32 = p.g;
    p.r = <u8>((r + g) >> 1);
    print(p.r.toString());                 // 200
}

Nullability

Nullable types are reference-only: string?, C?, (() => i32)?, with T?[] an array of nullable elements and T[]? a nullable array. There are no other unions, so T | null is an error. A nullable basic type (i32?) is a compile error. Nullability folds correctly per generic instance, so nullable array elements behave. Value classes exclude nullability entirely: null refuses a value-class target at compile time.

After x as T a ? followed by an operand starts a ternary, as in Dart. At the end of a line it makes T nullable, so a statement can end there without a semicolon, unless the next line is a ternary branch followed by its :. In a class body a member on the next line ends the field instead, so a field's ternary broken after as T ? needs that ? on the next line or parentheses. A basic type such as bool can never be nullable, so after a cast to one the ternary wins unless the next line can only be a member: one with an initializer or a body, or a field of a basic type or string.

The checker enforces the flag with a definite non-null analysis. A member access, call, index, for..of or cascade on a nullable value warns (W3004) unless the value is proven non-null on that path, and so does a nullable value, or null itself, stored into a non-nullable local, parameter, field, element or return. A proof comes from if (x != null) and if (x) for the then branch, if (x == null) for the else branch or for the rest of the block when the then branch returns, breaks, continues or throws, the right side of x != null && … and x == null || …, an assignment of a proven value, x ??= y or x ||= y with y proven, assert(x != null), and x!, which proves x from then on. A ternary, a || b or a ?? b whose arms are both proven counts as proven too.

Four operators work on nullable values, as in Dart:

• x! asserts x is not null and traps when it is. The check is skipped when the analysis already proved x, and inside unchecked().
• a ?? b is a unless it is null, evaluating b only then. The result is nullable only when b is. Beside || or && it needs parentheses, as in TypeScript.
• a ??= b stores b into a when a is null.
• a?.b, a?.m(), a?.[i] and f?.() stop at a null link and yield null for the whole chain, skipping everything after it, arguments included. A chain ending in a basic type such as a?.length cannot be null, so it needs a fallback, a?.length ?? 0, unless its value is dropped.

Field chains narrow like locals: after if (this.context != null) the chain this.context stays proven until a store through any prefix of it (this.context = …) or a method call on a proper prefix (this.reset()), since a method can store into its receiver's fields. A call on the chain itself (this.context.grow()) keeps the chain and only drops what sits below it. Inside a loop, every key the loop stores or calls through is unproven for the whole loop; a closure starts with no proofs, since captures are copies.

declare function print(s: string): void;

function firstName(names: Array<string?>): string {
    let n = names[0];
    if (n != null) {
        return n;          // narrowed to string
    }
    return "anonymous";
}

class User {
    name: string? = null;
    manager: User? = null;
}

export function demo(): void {
    let empty: Array<string?> = [null, "rasc"];
    let named: Array<string?> = ["rasc", null];
    print(firstName(empty));   // anonymous
    print(firstName(named));   // rasc

    let user = new User();
    print((user.manager?.name?.length ?? 0).toString());   // 0
    user.manager ??= new User();
    user.manager.name = "Ada";
    print(user.manager?.name ?? "nobody");                 // Ada
}

Reference classes

Ordinary classes are managed heap objects: a small header followed by naturally aligned fields. The header holds the runtime class id, which drives instanceof, virtual dispatch, and garbage collection. @unmanaged classes drop all of that — raw structs for low-level work, so they cannot implement interfaces, override methods, or extend or be extended by managed classes.

An interface, generic ones included, types a reference to any class that implements it, and calls through it dispatch on the runtime class. The compiler checks each implementation against every member of the interface; see Classes & Generics.

Value classes

struct types are plain-old-data with copy semantics — they live in wasm locals, flatten into their containers, and never allocate. They get their own chapter.

Function types

function apply(g: (x: i32) => i32, v: i32): i32 {
    return g(v);
}

export function demo(): i32 {
    let f: (x: i32) => i32 = (x: i32): i32 => x + 1;
    return apply(f, 41);   // 42
}

Plain functions and capturing closures mix freely behind the same function type, and a function-typed field or accessor calls directly: obj.fn(x). See Closures & Iteration.

Enums and namespaces

enum Color { Red, Green = 5, Blue }   // Blue == 6; values must be constant

namespace Geo {
    export function area(w: f64, h: f64): f64 { return w * h; }
}

export function demo(): f64 {
    return Geo.area(6, 7) + Color.Blue;   // 48
}

Nested namespace paths resolve through scopes and enums (String.UTF8.ErrorMode). Inside a namespace a member’s own name is that member, as in TypeScript, even in its own initializer, so namespace N { export const x = x + 1; } is an error, “'x' is read in its own initialization cycle”, rather than a read of an outer x. A member with a declared type reads its own zero there instead, as a top-level const y: i32 = y + 1 does.

SIMD

v128 works as locals, params, returns, and class fields, with f32x4 and i32x4 builtin families (splat, lane access, arithmetic, compares, abs/neg/sqrt, min/max, bitmask) plus the bitwise v128 operations, loads, stores and lane shuffles. SIMD is on by default in a Rive project. There is no v128.const, so there are no v128 globals. See SIMD for the full list and for keeping a scalar path beside the SIMD one with ASC_FEATURE_SIMD.

Type queries and layout builtins

sizeof<T>(), alignof<T>(), offsetof<T>("field") const-fold. For value classes they report payload size and alignment; for reference classes, pointer size. idof<T>() gives the runtime class id; isDefined, isBoolean, isArray, isFunction, and isNullable<T>() fold per monomorphized instance — pair them with constant if folding for compile-time specialization.