radiance · commit

lang: Parse linear and pointer types

8ed9e8cc40e335d07b37836be7c4d3e7d53c243a3dfb968507a20122b6bfab7a

Alexis Sellier committed 1 month ago 1 parent 6bcd1af1

lib/std/lang.rad +1 -0

//! Radiance language implementation.
export mod alloc;
export mod sexpr;
export mod types;
export mod strings;
export mod scanner;
export mod ast;
export mod parser;
export mod module;

lib/std/lang/ast.rad +15 -3

export mod printer;

use std::io;
use std::fmt;
use std::lang::alloc;
use std::lang::types;

/// Maximum number of trait methods.
export constant MAX_TRAIT_METHODS: u32 = 8;

/// Arena for all parser allocations.

    Extern = 0b100,
    /// Test-only declaration attribute.
    Test = 0b1000,
    /// Compiler intrinsic attribute.
    Intrinsic = 0b10000,
    /// Declaration may perform unsafe pointer operations.
    Unsafe = 0b100000,
}

/// Ordered collection of attribute nodes applied to a declaration.
export record Attributes {
    list: *mut [*Node],

        /// Array element type.
        itemType: *Node,
        /// Expression that evaluates to the array length.
        length: *Node,
    },
    /// Slice type, eg. `*[i32]` or `*mut [i32]`.
    /// Slice type, eg. `*[i32]`, `&[i32]`, or `*unsafe [i32]`.
    Slice {
        /// Ownership and safety class.
        class: types::PointerClass,
        /// Slice element type.
        itemType: *Node,
        /// Whether the slice is mutable.
        mutable: bool,
    },
    /// Pointer, eg. `*i32` or `*mut i32`.
    /// Pointer type, eg. `*i32`, `&i32`, or `*unsafe i32`.
    Pointer {
        /// Ownership and safety class.
        class: types::PointerClass,
        /// Pointer target type.
        valueType: *Node,
        /// Whether the pointer is mutable.
        mutable: bool,
    },

        /// Whether this record has labeled fields.
        labeled: bool,
    },
    /// Anonymous function type.
    Fn(FnSig),
    /// Trait object type, eg. `*opaque Allocator`.
    /// Trait object type, eg. `*opaque Allocator`, `&opaque Allocator`, or
    /// `*unsafe opaque Allocator`.
    TraitObject {
        /// Ownership and safety class.
        class: types::PointerClass,
        /// Trait name identifier.
        traitName: *Node,
        /// Whether the pointer is mutable.
        mutable: bool,
    },

        name: *Node,
        /// Receiver type node (eg. `*mut Allocator`).
        receiver: *Node,
        /// Function signature.
        sig: FnSig,
        /// Optional declaration modifiers.
        attrs: ?Attributes,
    },
    /// Instance block.
    InstanceDecl {
        /// Trait name identifier.
        traitName: *Node,

lib/std/lang/ast/printer.rad +64 -13

//! AST pretty printer using S-expression syntax.

use std::io;
use std::lang::sexpr;
use std::lang::alloc;
use std::lang::types;

/// Return the symbol for a binary operator.
fn binOpName(op: super::BinaryOp) -> *[u8] {
    match op {
        case super::BinaryOp::Add => return "+",

            else => panic,
        }
    }
}

/// Return the S-expression head for a pointer class.
fn pointerClassHead(
    class: types::PointerClass,
    ownedHead: *[u8],
    refHead: *[u8],
    unsafeHead: *[u8],
) -> *[u8] {
    match class {
        case types::PointerClass::Owned => return ownedHead,
        case types::PointerClass::Ref => return refHead,
        case types::PointerClass::Unsafe => return unsafeHead,
    }
}

/// Convert a type signature to an S-expression.
fn typeSigToExpr(a: *mut alloc::Arena, sig: super::TypeSig) -> sexpr::Expr {
    match sig {
        case super::TypeSig::Void => return sexpr::sym("void"),
        case super::TypeSig::Opaque => return sexpr::sym("opaque"),
        case super::TypeSig::Bool => return sexpr::sym("bool"),
        case super::TypeSig::Integer { width, sign } => return sexpr::sym(intTypeName(width, sign)),
        case super::TypeSig::Array { itemType, length } =>
            return sexpr::list(a, "array", &[toExpr(a, itemType), toExpr(a, length)]),
        case super::TypeSig::Slice { itemType, mutable } =>
            return sexpr::list(a, "slice", &[sexpr::sym("mut"), toExpr(a, itemType)]) if mutable
                else sexpr::list(a, "slice", &[toExpr(a, itemType)]),
        case super::TypeSig::Pointer { valueType, mutable } =>
            return sexpr::list(a, "ptr", &[sexpr::sym("mut"), toExpr(a, valueType)]) if mutable
                else sexpr::list(a, "ptr", &[toExpr(a, valueType)]),
        case super::TypeSig::Slice { class, itemType, mutable } => {
            let head = pointerClassHead(class, "slice", "slice-ref", "unsafe-slice");
            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, itemType)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, itemType)]);
        }
        case super::TypeSig::Pointer { class, valueType, mutable } => {
            let head = pointerClassHead(class, "ptr", "ref", "unsafe-ptr");
            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, valueType)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, valueType)]);
        }
        case super::TypeSig::Optional { valueType } =>
            return sexpr::list(a, "?", &[toExpr(a, valueType)]),
        case super::TypeSig::Nominal(name) => return toExpr(a, name),
        case super::TypeSig::Record { fields, .. } =>
            return sexpr::list(a, "record", nodeListToExprs(a, &fields[..])),

            if let rt = sig.returnType {
                set ret = toExpr(a, rt);
            }
            return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
        }
        case super::TypeSig::TraitObject { traitName, mutable } =>
            return sexpr::list(a, "obj", &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
                else sexpr::list(a, "obj", &[toExpr(a, traitName)]),
        case super::TypeSig::TraitObject { class, traitName, mutable } => {
            let head = pointerClassHead(class, "obj", "obj-ref", "unsafe-obj");
            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, traitName)]);
        }
    }
}

/// Convert a node slice to a slice of expressions.
fn nodeListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {

        set buf[i] = toExpr(a, node);
    }
    return buf;
}

/// Convert optional attributes to an attribute list expression.
fn attributesToExpr(a: *mut alloc::Arena, attrs: ?super::Attributes) -> sexpr::Expr {
    let mut exprs: *[sexpr::Expr] = &[];
    if let list = attrs {
        set exprs = nodeListToExprs(a, &list.list[..]);
    }
    return sexpr::list(a, "attrs", exprs);
}

/// Convert an optional node to an expression, or return placeholder.
fn toExprOpt(a: *mut alloc::Arena, opt: ?*super::Node) -> sexpr::Expr {
    if let n = opt {
        return toExpr(a, n);
    }

                case super::Attribute::Export => return sexpr::sym("@export"),
                case super::Attribute::Default => return sexpr::sym("@default"),
                case super::Attribute::Extern => return sexpr::sym("@extern"),
                case super::Attribute::Test => return sexpr::sym("@test"),
                case super::Attribute::Intrinsic => return sexpr::sym("@intrinsic"),
                case super::Attribute::Unsafe => return sexpr::sym("@unsafe"),
            }
        }
        case super::NodeValue::Try(t) => {
            let mut head = "try";
            if t.shouldPanic { set head = "try!"; }

        case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
            let children = nodeListToExprs(a, &methods[..]);
            let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
            return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
        }
        case super::NodeValue::TraitMethodSig { name, receiver, sig } => {
        case super::NodeValue::TraitMethodSig { name, receiver, sig, attrs } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            let ret = toExprOrNull(a, sig.returnType);
            return sexpr::list(a, "methodSig", &[toExpr(a, receiver), toExpr(a, name), params, ret]);
            let attributes = attributesToExpr(a, attrs);
            return sexpr::list(
                a,
                "methodSig",
                &[attributes, toExpr(a, receiver), toExpr(a, name), params, ret],
            );
        }
        case super::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            let children = nodeListToExprs(a, &methods[..]);
            return sexpr::block(a, "instance", &[toExpr(a, traitName), toExpr(a, targetType)], children);
        }
        case super::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, .. } => {
        case super::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, attrs,
        } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            let ret = toExprOrNull(a, sig.returnType);
            return sexpr::block(a, "method", &[toExpr(a, receiverType), toExpr(a, receiverName), toExpr(a, name), params, ret], &[toExpr(a, body)]);
            let attributes = attributesToExpr(a, attrs);
            return sexpr::block(
                a,
                "method",
                &[
                    attributes,
                    toExpr(a, receiverType),
                    toExpr(a, receiverName),
                    toExpr(a, name),
                    params,
                    ret,
                ],
                &[toExpr(a, body)],
            );
        }
        else => return sexpr::sym("?"),
    }
}


lib/std/lang/lower.rad +16 -9

//!   il::Data
//!
use std::fmt;
use std::io;
use std::lang::alloc;
use std::lang::types;
use std::mem;
use std::lang::ast;
use std::lang::il;
use std::lang::module;
use std::lang::resolver;

fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
    match optType {
        case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
            return il::Val::Imm(0);
        }
        case resolver::Type::Optional(resolver::Type::Slice { item, mutable }) => {
        case resolver::Type::Optional(resolver::Type::Slice { item, mutable, .. }) => {
            return try buildSliceValue(self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0));
        }
        case resolver::Type::Optional(inner) => {
            let valOffset = resolver::getOptionalValOffset(*inner) as i32;
            return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);

    mutable: bool,
    ptrVal: il::Val,
    lenVal: il::Val,
    capVal: il::Val
) -> il::Val throws (LowerError) {
    let sliceType = resolver::Type::Slice { item: elemTy, mutable };
    let sliceType = resolver::Type::Slice {
        class: types::PointerClass::Owned, item: elemTy, mutable,
    };
    let dst = try emitReserve(self, sliceType);
    let ptrTy = resolver::Type::Pointer { target: elemTy, mutable };
    let ptrTy = resolver::Type::Pointer {
        class: types::PointerClass::Owned, target: elemTy, mutable,
    };

    try emitStore(self, dst, SLICE_PTR_OFFSET, ptrTy, ptrVal);
    try emitStore(self, dst, SLICE_LEN_OFFSET, resolver::Type::U32, lenVal);
    try emitStore(self, dst, SLICE_CAP_OFFSET, resolver::Type::U32, capVal);


    mutable: bool,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
    let ptrTy = resolver::Type::Pointer { target: elemTy, mutable };
    let ptrTy = resolver::Type::Pointer {
        class: types::PointerClass::Owned, target: elemTy, mutable,
    };
    let ptrEq = try emitEqAtOffset(self, a, b, offset + SLICE_PTR_OFFSET, ptrTy);
    let lenEq = try emitEqAtOffset(self, a, b, offset + SLICE_LEN_OFFSET, resolver::Type::U32);

    return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, ptrEq, lenEq);
}

    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
    match typ {
        case resolver::Type::Optional(resolver::Type::Slice { item, mutable }) => {
        case resolver::Type::Optional(resolver::Type::Slice { item, mutable, .. }) => {
            // Optional slices use null pointer optimization.
            return try lowerSliceEq(self, item, mutable, a, b, offset);
        }
        case resolver::Type::Optional(inner) => {
            return try lowerOptionalEq(self, *inner, a, b, offset);
        }
        case resolver::Type::Slice { item, mutable } =>
        case resolver::Type::Slice { item, mutable, .. } =>
            return try lowerSliceEq(self, item, mutable, a, b, offset),
        case resolver::Type::Array(arr) =>
            return try lowerArrayEq(self, arr, a, b, offset),
        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) =>
            return try lowerRecordEq(self, recInfo, a, b, offset),

    self: *mut FnLowerer,
    sliceNode: *ast::Node,
    arrayNode: *ast::Node
) -> il::Val throws (LowerError) {
    let sliceTy = try typeOf(self, sliceNode);
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
        throw LowerError::UnexpectedType(&sliceTy);
    };
    let arrayTy = try typeOf(self, arrayNode);
    let case resolver::Type::Array(arrayInfo) = arrayTy else {
        throw LowerError::ExpectedArray;

/// String literals are stored as global data and the result is a slice
/// pointing to the data with the appropriate length.
fn lowerStringLit(self: *mut FnLowerer, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
    // Get the slice type from the node.
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
        throw LowerError::ExpectedSliceOrArray;
    };
    // Build the string data value.
    let ptr = try! alloc::alloc(
        self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)

fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    if args.len <> 2 and args.len <> 3 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
        throw LowerError::ExpectedSliceOrArray;
    };
    let ptrVal = try lowerExpr(self, args[0]);
    let lenVal = try lowerExpr(self, args[1]);
    let mut capVal = lenVal;

lib/std/lang/parser.rad +39 -21


use std::mem;
use std::io;
use std::fmt;
use std::lang::alloc;
use std::lang::types;
use std::lang::ast;
use std::lang::strings;
use std::lang::scanner;

/// Maximum `u32` value.

        ));
    }
    throw failParsing(p, "expected assignment after `set`");
}

/// Parse leading attributes attached to the next declaration statement.
/// Parse leading attributes and declaration modifiers.
fn parseAttributes(p: *mut Parser) -> ?ast::Attributes {
    let mut attrs = ast::nodeSlice(p.arena, 4);

    if let attr = tryParseAnnotation(p) {
        attrs.append(attr, p.allocator);
    }
    if consume(p, scanner::TokenKind::Export) {
        let attrNode = nodeAttribute(p, ast::Attribute::Export);
        attrs.append(attrNode, p.allocator);
        attrs.append(nodeAttribute(p, ast::Attribute::Export), p.allocator);
    }
    if consume(p, scanner::TokenKind::Unsafe) {
        attrs.append(nodeAttribute(p, ast::Attribute::Unsafe), p.allocator);
    }
    if attrs.len > 0 {
        return ast::Attributes { list: attrs };
    }
    return nil;

{
    // TODO: Why is `parseStmt` checking for attributes?
    // We should have a `parseDecl` which is top-level, and `parseStmt` which
    // is inside functions.
    let attrs = parseAttributes(p);
    if attrs <> nil {
    if let list = attrs {
        if ast::attributesContains(&list, ast::Attribute::Unsafe)
            and p.current.kind <> scanner::TokenKind::Fn
            and p.current.kind <> scanner::TokenKind::Mod
        {
            throw failParsing(p, "`unsafe` is only allowed on functions and modules");
        }
        let allowed: bool =
            p.current.kind == scanner::TokenKind::Fn or
            p.current.kind == scanner::TokenKind::Union or
            p.current.kind == scanner::TokenKind::Record or
            p.current.kind == scanner::TokenKind::Mod or

    return node(p, ast::NodeValue::FnDecl(
        ast::FnDecl { name, sig, body, attrs: fnAttrs }
    ));
}

/// Parse a pointer or slice type.
fn parsePointerType(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Star, "expected `*`");
/// Parse a pointer-like type after its ownership prefix.
fn parsePointerLikeType(
    p: *mut Parser,
    class: types::PointerClass,
) -> *ast::Node throws (ParseError) {
    let mutable = consume(p, scanner::TokenKind::Mut);

    if consume(p, scanner::TokenKind::LBracket) {
        let itemType = try parseType(p);
        try expect(p, scanner::TokenKind::RBracket, "expected `]` after slice element type");

        return node(p, ast::NodeValue::TypeSig(
            ast::TypeSig::Slice { itemType, mutable }
            ast::TypeSig::Slice { class, itemType, mutable }
        ));
    }
    // Check for `*opaque Trait` or `*mut opaque Trait`.
    // Check for an opaque trait object.
    if consume(p, scanner::TokenKind::Opaque) {
        if check(p, scanner::TokenKind::Ident) or check(p, scanner::TokenKind::Super) {
            let traitName = try parseTypePath(p);
            return node(p, ast::NodeValue::TypeSig(
                ast::TypeSig::TraitObject { traitName, mutable }
                ast::TypeSig::TraitObject { class, traitName, mutable }
            ));
        }
        // Plain `*opaque`.
        // Plain opaque target.
        let valueType = node(p, ast::NodeValue::TypeSig(ast::TypeSig::Opaque));
        return node(p, ast::NodeValue::TypeSig(
            ast::TypeSig::Pointer {
                valueType: node(p, ast::NodeValue::TypeSig(ast::TypeSig::Opaque)),
                mutable,
            }
            ast::TypeSig::Pointer { class, valueType, mutable }
        ));
    }
    let valueType = try parseType(p);

    return node(p, ast::NodeValue::TypeSig(
        ast::TypeSig::Pointer { valueType, mutable }
        ast::TypeSig::Pointer { class, valueType, mutable }
    ));
}

/// Parse an array type.
fn parseArrayType(p: *mut Parser) -> *ast::Node

            return node(p, ast::NodeValue::TypeSig(
                ast::TypeSig::Optional { valueType }
            ));
        }
        case scanner::TokenKind::Star => {
            return try parsePointerType(p);
            advance(p);
            let class = types::PointerClass::Unsafe
                if consume(p, scanner::TokenKind::Unsafe)
                else types::PointerClass::Owned;
            return try parsePointerLikeType(p, class);
        }
        case scanner::TokenKind::Amp => {
            advance(p);
            return try parsePointerLikeType(p, types::PointerClass::Ref);
        }
        case scanner::TokenKind::LBracket => {
            return try parseArrayType(p);
        }
        case scanner::TokenKind::Super, scanner::TokenKind::Ident => {

/// Parse a trait method signature.
/// Syntax: `fn (*Trait) fnord(<params>) -> ReturnType;`
fn parseTraitMethodSig(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    let attrs = parseAttributes(p);
    try expect(p, scanner::TokenKind::Fn, "expected `fn`");
    try expect(p, scanner::TokenKind::LParen, "expected `(` before receiver");

    let receiver = try parseType(p);



    let name = try parseIdent(p, "expected method name");
    let sig = try parseFnTypeSig(p);
    try expect(p, scanner::TokenKind::Semicolon, "expected `;` after method signature");

    return node(p, ast::NodeValue::TraitMethodSig { name, receiver, sig });
    return node(p, ast::NodeValue::TraitMethodSig { name, receiver, sig, attrs });
}

/// Parse an instance block.
/// Syntax: `instance Trait for Type { fn (t: *mut Type) fnord(..) {..} }`
///

    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
    let targetType = try parseTypePath(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");

    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);

    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let attrs = parseAttributes(p);
        try expect(p, scanner::TokenKind::Fn, "expected `fn`");
        let method = try parseMethodDecl(p, nil);
        let method = try parseMethodDecl(p, attrs);

        methods.append(method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after instance methods");


lib/std/lang/parser/tests.rad +153 -21


use std::mem;
use std::fmt;
use std::testing;
use std::lang::ast;
use std::lang::types;
use std::lang::alloc;
use std::lang::sexpr;
use std::lang::ast::printer;
use std::lang::scanner;
use std::lang::strings;

/// Unified arena size.
constant ARENA_SIZE: u32 = 2097152;

        else throw testing::TestError::Failed;

    try expectIntType(opt, 4, ast::Signedness::Signed);
}

/// Test parsing a pointer type, including `mut`.
@test fn testParseTypePointer() throws (testing::TestError) {
    let node = try! parseTypeStr("*mut i32");
/// Parse an `i32` pointer type and verify its class and mutability.
fn expectI32Pointer(
    source: *[u8],
    class: types::PointerClass,
    mutable: bool,
) throws (testing::TestError) {
    let node = try! parseTypeStr(source);
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer { valueType, mutable } = sig
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer {
        class: actualClass, valueType, mutable: actualMutable,
    } = sig else throw testing::TestError::Failed;

    assert actualClass == class;
    try expectIntType(valueType, 4, ast::Signedness::Signed);
    try testing::expect(mutable);
    assert actualMutable == mutable;
}

/// Test parsing a mutable owned pointer.
@test fn testParseTypePointer() throws (testing::TestError) {
    try expectI32Pointer("*mut i32", types::PointerClass::Owned, true);
}

/// Test parsing an immutable pointer type.
/// Test parsing an immutable owned pointer.
@test fn testParseTypePointerImmutable() throws (testing::TestError) {
    let node = try! parseTypeStr("*i32");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer { valueType, mutable } = sig
        else throw testing::TestError::Failed;
    try expectI32Pointer("*i32", types::PointerClass::Owned, false);
}

    try expectIntType(valueType, 4, ast::Signedness::Signed);
    try testing::expect(not mutable);
/// Test parsing immutable and mutable references.
@test fn testParseTypeRef() throws (testing::TestError) {
    try expectI32Pointer("&i32", types::PointerClass::Ref, false);
    try expectI32Pointer("&mut i32", types::PointerClass::Ref, true);
}

/// Test parsing immutable and mutable unsafe pointers.
@test fn testParseTypeUnsafePointer() throws (testing::TestError) {
    try expectI32Pointer("*unsafe i32", types::PointerClass::Unsafe, false);
    try expectI32Pointer("*unsafe mut i32", types::PointerClass::Unsafe, true);
}

/// Test parsing a slice type.
@test fn testParseTypeSlice() throws (testing::TestError) {
    let node = try! parseTypeStr("*[u8]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { itemType, mutable } = sig
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    assert class == types::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    try testing::expect(not mutable);
    assert not mutable;
}

/// Test parsing a mutable slice type.
@test fn testParseTypeSliceMutable() throws (testing::TestError) {
    let node = try! parseTypeStr("*mut [u8]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { itemType, mutable } = sig
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    assert class == types::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    try testing::expect(mutable);
    assert mutable;
}

/// Test parsing reference and unsafe slice classes.
@test fn testParseTypeSliceClasses() throws (testing::TestError) {
    let refNode = try! parseTypeStr("&[u8]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
        class: refClass, ..
    }) = refNode.value else throw testing::TestError::Failed;
    assert refClass == types::PointerClass::Ref;

    let unsafeNode = try! parseTypeStr("*unsafe [u8]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
        class: unsafeClass, ..
    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == types::PointerClass::Unsafe;
}

/// Test parsing trait object pointer classes.
@test fn testParseTypeTraitObjectClasses() throws (testing::TestError) {
    let ownedNode = try! parseTypeStr("*opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: ownedClass, ..
    }) = ownedNode.value else throw testing::TestError::Failed;
    assert ownedClass == types::PointerClass::Owned;

    let refNode = try! parseTypeStr("&opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: refClass, ..
    }) = refNode.value else throw testing::TestError::Failed;
    assert refClass == types::PointerClass::Ref;

    let unsafeNode = try! parseTypeStr("*unsafe opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: unsafeClass, ..
    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == types::PointerClass::Unsafe;
}

/// Test parsing an array type.
@test fn testParseTypeArray() throws (testing::TestError) {
    let node = try! parseTypeStr("[i32; 4]");

    try expectIntType(param0, 4, ast::Signedness::Signed);

    let param1 = sig.params[1];
    let case ast::NodeValue::TypeSig(p1) = param1.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer { valueType: ptrTarget, mutable: _ } = p1
    let case ast::TypeSig::Pointer { valueType: ptrTarget, .. } = p1
        else throw testing::TestError::Failed;
    try expectIntType(ptrTarget, 1, ast::Signedness::Unsigned);

    try testing::expect(sig.returnType <> nil);
}

    let mut parser = super::mkParser(scanner::SourceLoc::String, "void", &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);
    try testing::expect(super::check(&parser, scanner::TokenKind::Ident));
}

/// Test parsing the unsafe function modifier.
@test fn testParseUnsafeFnDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("unsafe fn run() {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;
    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 1);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Unsafe));
}

/// Test rejecting `unsafe` on declarations where it has no semantics.
@test fn testParseUnsafeUnsupportedDecl() throws (testing::TestError) {
    let recordDecl: ?*ast::Node = try? parseStmtStr("unsafe record R {}");
    try testing::expect(recordDecl == nil);
    let constDecl: ?*ast::Node = try? parseStmtStr("unsafe constant X = 1;");
    try testing::expect(constDecl == nil);
}

/// Test `unsafe` on the other declaration forms that support it.
@test fn testParseUnsafeMethodAndModule() throws (testing::TestError) {
    let moduleNode = try! parseStmtStr("unsafe mod io;");
    let case ast::NodeValue::Mod(moduleDecl) = moduleNode.value
        else throw testing::TestError::Failed;
    let moduleAttrs = moduleDecl.attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&moduleAttrs, ast::Attribute::Unsafe);

    let instanceNode = try! parseStmtStr(
        "instance Read for Value { unsafe fn (value: &Value) get() {} }"
    );
    let case ast::NodeValue::InstanceDecl { methods, .. } = instanceNode.value
        else throw testing::TestError::Failed;
    try testing::expect(methods.len == 1);
    let case ast::NodeValue::MethodDecl { attrs, .. } = methods[0].value
        else throw testing::TestError::Failed;
    let methodAttrs = attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&methodAttrs, ast::Attribute::Unsafe);

    let mut printStorage: [u8; 4096] = undefined;
    let mut printArena = alloc::new(&mut printStorage[..]);
    let methodExpr = printer::toExpr(&mut printArena, methods[0]);
    let case sexpr::Expr::Block { items: methodItems, .. } = methodExpr
        else throw testing::TestError::Failed;
    let case sexpr::Expr::List {
        head: methodAttrsHead, tail: printedMethodAttrs, ..
    } = methodItems[0] else throw testing::TestError::Failed;
    assert mem::eq(methodAttrsHead, "attrs");
    let case sexpr::Expr::Sym(methodAttr) = printedMethodAttrs[0]
        else throw testing::TestError::Failed;
    assert mem::eq(methodAttr, "@unsafe");

    let traitNode = try! parseStmtStr(
        "trait Read { unsafe fn (&Read) get(); }"
    );
    let case ast::NodeValue::TraitDecl { methods: traitMethods, .. } = traitNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TraitMethodSig {
        attrs: traitAttrs, ..
    } = traitMethods[0].value else throw testing::TestError::Failed;
    let traitMethodAttrs = traitAttrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&traitMethodAttrs, ast::Attribute::Unsafe);

    let traitMethodExpr = printer::toExpr(&mut printArena, traitMethods[0]);
    let case sexpr::Expr::List { tail: traitMethodItems, .. } = traitMethodExpr
        else throw testing::TestError::Failed;
    let case sexpr::Expr::List {
        head: traitAttrsHead, tail: printedTraitAttrs, ..
    } = traitMethodItems[0] else throw testing::TestError::Failed;
    assert mem::eq(traitAttrsHead, "attrs");
    let case sexpr::Expr::Sym(traitAttr) = printedTraitAttrs[0]
        else throw testing::TestError::Failed;
    assert mem::eq(traitAttr, "@unsafe");
}

/// Test parsing a function declaration with attributes.
@test fn testParseFnDeclAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("export fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

@test fn testParseTypeBool() throws (testing::TestError) {
    let node = try! parseTypeStr("bool");
    try expectType(node, ast::TypeSig::Bool);
}


/// Test parsing an unsigned integer type.
@test fn testParseTypeUnsigned() throws (testing::TestError) {
    let node = try! parseTypeStr("u8");
    try expectType(node, ast::TypeSig::Integer {
        width: 1,

        try expectIdent(access.child, "field");
    }
}

/// Test parsing reference (address-of) expressions.
@test fn testParseReferences() throws (testing::TestError) {
@test fn testParseRefs() throws (testing::TestError) {
    {
        let refExpr = try! parseExprStr("&foo");
        let case ast::NodeValue::AddressOf(refNode) = refExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(refNode.mutable == false);

lib/std/lang/resolver.rad +76 -38

// TODO: Have different types for positional vs. named field records.

use std::mem;
use std::io;
use std::lang::alloc;
use std::lang::types;
use std::lang::ast;
use std::lang::parser;
use std::lang::module;

/// Maximum number of diagnostics recorded.

    /// Range types, eg. `start..end`.
    Range {
        start: ?*Type,
        end: ?*Type,
    },
    /// Eg. `*T`.
    /// Pointer-like address.
    Pointer {
        class: types::PointerClass,
        target: *Type,
        mutable: bool,
    },
    /// Eg. `*[i32]`.
    /// Pointer-like slice.
    Slice {
        class: types::PointerClass,
        item: *Type,
        mutable: bool,
    },
    /// Eg. `[i32; 32]`.
    Array(ArrayType),

    Optional(*Type),
    /// Eg. `fn id(i32) -> i32`.
    Fn(*FnType),
    /// Named, ie. user-defined types, includes union variants.
    Nominal(*NominalType),
    /// Trait object. An erased type with v-table.
    /// An erased pointer-like type with a v-table.
    TraitObject {
        /// Ownership and safety class.
        class: types::PointerClass,
        /// Trait definition.
        traitInfo: *TraitType,
        /// Whether the pointer is mutable.
        mutable: bool,
    },

    by: MatchBy,
}

/// Unwrap a pointer type for pattern matching.
export fn unwrapMatchSubject(ty: Type) -> MatchSubject {
    if let case Type::Pointer { target, mutable } = ty {
    if let case Type::Pointer { target, mutable, .. } = ty {
        let by = MatchBy::MutRef if mutable else MatchBy::Ref;
        return MatchSubject { effectiveTy: *target, by };
    }
    return MatchSubject { effectiveTy: ty, by: MatchBy::Value };
}

                    }
                    return nil;
                }
            }
        }
        case Type::Pointer { target: lhsTarget, mutable: lhsMutable } => {
            let case Type::Pointer { target: rhsTarget, mutable: rhsMutable } = from
        case Type::Pointer { target: lhsTarget, mutable: lhsMutable, .. } => {
            let case Type::Pointer { target: rhsTarget, mutable: rhsMutable, .. } = from
                else return nil;

            // Allow coercion from `*T` to `*opaque`, and `*mut T` to `*mut opaque`.
            if *lhsTarget == Type::Opaque {
                if lhsMutable and not rhsMutable {

            if let case Type::Optional(fromInner) = from {
                return isAssignable(self, *inner, *fromInner, rval);
            }
            return nil;
        }
        case Type::TraitObject { traitInfo, mutable: lhsMutable } => {
        case Type::TraitObject {
            class: lhsClass, traitInfo, mutable: lhsMutable,
        } => {
            // Coerce `*T` or `*mut T` where `T` implements the trait.
            if let case Type::Pointer { target, mutable: rhsMutable } = from {
            if let case Type::Pointer { target, mutable: rhsMutable, .. } = from {
                if lhsMutable and not rhsMutable {
                    return nil;
                }
                // Look up instance registry.
                if let inst = findInstance(self, traitInfo, *target) {
                    return Coercion::TraitObject { traitInfo, inst };
                }
            }
            // Identity: same trait object.
            if let case Type::TraitObject { traitInfo: rhsTrait, mutable: rhsMutable } = from {
                if traitInfo <> rhsTrait {
            if let case Type::TraitObject {
                class: rhsClass, traitInfo: rhsTrait, mutable: rhsMutable,
            } = from {
                if lhsClass <> rhsClass or traitInfo <> rhsTrait {
                    return nil;
                }
                if lhsMutable and not rhsMutable {
                    return nil;
                }
                return Coercion::Identity;
            }
            return nil;
        }
        case Type::Slice { item: lhsItem, mutable: lhsMutable } => {
        case Type::Slice { class: lhsClass, item: lhsItem, mutable: lhsMutable } => {
            match from {
                case Type::Slice { item: rhsItem, mutable: rhsMutable } => {
                case Type::Slice { class: rhsClass, item: rhsItem, mutable: rhsMutable } => {
                    if lhsClass <> rhsClass {
                        return nil;
                    }
                    if lhsMutable and not rhsMutable {
                        return nil;
                    }
                    // Allow coercion from `*[T]` to `*[opaque]`, and `*mut [T]` to `*mut [opaque]`.
                    if *lhsItem == Type::Opaque {

export fn typesEqual(a: Type, b: Type) -> bool {
    if a == b {
        return true;
    }
    match a {
        case Type::Pointer { target: aTarget, mutable: aMutable } => {
            let case Type::Pointer { target: bTarget, mutable: bMutable } = b else return false;
            return aMutable == bMutable and typesEqual(*aTarget, *bTarget);
        case Type::Pointer { class: aClass, target: aTarget, mutable: aMutable } => {
            let case Type::Pointer { class: bClass, target: bTarget, mutable: bMutable } = b
                else return false;
            return aClass == bClass and aMutable == bMutable and typesEqual(*aTarget, *bTarget);
        }
        case Type::Slice { item: aItem, mutable: aMutable } => {
            let case Type::Slice { item: bItem, mutable: bMutable } = b else return false;
            return aMutable == bMutable and typesEqual(*aItem, *bItem);
        case Type::Slice { class: aClass, item: aItem, mutable: aMutable } => {
            let case Type::Slice { class: bClass, item: bItem, mutable: bMutable } = b
                else return false;
            return aClass == bClass and aMutable == bMutable and typesEqual(*aItem, *bItem);
        }
        case Type::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return aa.length == ab.length and typesEqual(*aa.item, *ab.item);
        }

            if index >= recInfo.fields.len {
                return nil;
            }
            return recInfo.fields[index];
        }
        case Type::Slice { item, mutable } => {
        case Type::Slice { item, mutable, .. } => {
            match index {
                case 0 => return RecordField {
                    name: PTR_FIELD,
                    fieldType: Type::Pointer { target: item, mutable },
                    fieldType: Type::Pointer {
                        class: types::PointerClass::Owned, target: item, mutable,
                    },
                    offset: 0,
                },
                case 1 => return RecordField {
                    name: LEN_FIELD,
                    fieldType: Type::U32,

        case ast::NodeValue::Try(expr) => return try resolveTry(self, node, expr, hint),
        case ast::NodeValue::Return { value } => return try resolveReturn(self, node, value),
        case ast::NodeValue::Throw { expr } => return try resolveThrow(self, node, expr),
        case ast::NodeValue::Panic { message } => {
            try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false
            });
            return setNodeType(self, node, Type::Never);
        },
        case ast::NodeValue::Assert { condition, message } => {
            try visit(self, condition, Type::Bool);
            try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false
            });
            return setNodeType(self, node, Type::Void);
        },

        }
        case ast::NodeValue::String(text) => {
            setNodeConstValue(self, node, ConstValue::String(text));
            let byteTy = allocType(self, Type::U8);
            let sliceTy = allocType(self, Type::Slice {
                class: types::PointerClass::Owned,
                item: byteTy,
                mutable: false,
            });
            return setNodeType(self, node, *sliceTy);
        },

            actual: traitType.methods.len as u32 + methods.len as u32,
        }));
    }

    for methodNode in methods {
        let case ast::NodeValue::TraitMethodSig { name, receiver, sig } = methodNode.value
        let case ast::NodeValue::TraitMethodSig { name, receiver, sig, .. } = methodNode.value
            else continue;
        let methodName = try nodeName(self, name);

        // Reject duplicate method names.
        if let _ = findTraitMethod(traitType, methodName) {

        }
        // Determine receiver mutability from the receiver type node
        // and validate that the receiver points to the declaring trait.
        let case ast::NodeValue::TypeSig(typeSig) = receiver.value
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Pointer { mutable, valueType } = typeSig
        let case ast::TypeSig::Pointer { mutable, valueType, .. } = typeSig
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::NodeValue::TypeSig(innerSig) = valueType.value
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Nominal(nameNode) = innerSig
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);


        // Determine receiver mutability and validate receiver type.
        // The receiver must be `*Type` or `*mut Type`.
        let case ast::NodeValue::TypeSig(typeSig) = receiverType.value
            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Pointer { mutable: receiverMut, valueType } = typeSig
        let case ast::TypeSig::Pointer { mutable: receiverMut, valueType, .. } = typeSig
            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);

        // Validate that the receiver type annotation matches the
        // concrete type from the instance declaration.
        let annotatedTy = try infer(self, valueType);

        }

        // Build the function type for the instance method.
        // The receiver becomes the first parameter.
        let receiverPtrType = Type::Pointer {
            class: types::PointerClass::Owned,
            target: allocType(self, concreteType),
            mutable: receiverMut,
        };

        // Validate that the instance method's signature matches the

    attrs: ?ast::Attributes,
) throws (ResolveError) {
    // Resolve the receiver type: must be `*Type` or `*mut Type` pointing to a
    // nominal type.
    let fullReceiverTy = try infer(self, receiverType);
    let case Type::Pointer { target, mutable: receiverMut } = fullReceiverTy
    let case Type::Pointer { target, mutable: receiverMut, .. } = fullReceiverTy
        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    let concreteType = *target;
    let case Type::Nominal(nominalTy) = concreteType
        else throw emitError(self, receiverType, ErrorKind::ExpectedRecord);
    try ensureNominalResolved(self, nominalTy, receiverType);

    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];

    // Receiver is the first parameter.
    let receiverPtrType = Type::Pointer {
        class: types::PointerClass::Owned,
        target: allocType(self, concreteType),
        mutable: receiverMut,
    };
    paramTypes.append(allocType(self, receiverPtrType), a);


    throws (ResolveError)
{
    let mut bindTy = ty;
    match matchBy {
        case MatchBy::Value => {}
        case MatchBy::Ref => set bindTy = Type::Pointer { target: allocType(self, ty), mutable: false },
        case MatchBy::MutRef => set bindTy = Type::Pointer { target: allocType(self, ty), mutable: true },
        case MatchBy::Ref => set bindTy = Type::Pointer {
            class: types::PointerClass::Owned, target: allocType(self, ty), mutable: false,
        },
        case MatchBy::MutRef => set bindTy = Type::Pointer {
            class: types::PointerClass::Owned, target: allocType(self, ty), mutable: true,
        },
    }
    match binding.value {
        case ast::NodeValue::Placeholder => {
            // Nothing to do.
        }

                expected: 2,
                actual: args.len as u32,
            }));
        }
        let ptrType = try visit(self, args[0], Type::Unknown);
        let case Type::Pointer { target, mutable } = ptrType else {
        let case Type::Pointer { target, mutable, .. } = ptrType else {
            throw emitError(self, node, ErrorKind::ExpectedPointer);
        };
        let _ = try checkAssignable(self, args[1], Type::U32);
        if args.len == 3 {
            let _ = try checkAssignable(self, args[2], Type::U32);
        }
        return setNodeType(self, node, Type::Slice { item: target, mutable });
        return setNodeType(self, node, Type::Slice {
            class: types::PointerClass::Owned, item: target, mutable,
        });
    }
    if args.len <> 1 {
        throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,

    // Intercept method calls on slices before inferring the callee.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {
        let parentTy = try infer(self, access.parent);
        let subjectTy = autoDeref(parentTy);

        if let case Type::Slice { item, mutable } = subjectTy {
        if let case Type::Slice { item, mutable, .. } = subjectTy {
            let methodName = try nodeName(self, access.child);
            if methodName == "append" {
                return try resolveSliceAppend(self, node, access.parent, parentTy, call.args, item, mutable);
            }
            if methodName == "delete" {

        if let t = typeFor(self, access.parent) {
            set parentTy = t;
        }
        let subjectTy = autoDeref(parentTy);

        if let case Type::TraitObject { traitInfo, mutable: objMutable } = subjectTy {
        if let case Type::TraitObject { traitInfo, mutable: objMutable, .. } = subjectTy {
            let methodName = try nodeName(self, access.child);
            let method = findTraitMethod(traitInfo, methodName)
                else throw emitError(self, access.child, ErrorKind::RecordFieldUnknown(methodName));

            // Reject mutable-receiver methods called on immutable trait objects.

                case Type::Array(a) => {
                    try validateArraySliceBounds(self, range, a.length, node);
                    set item = a.item;
                    set capacity = a.length;
                }
                case Type::Slice { item: i, mutable } => {
                case Type::Slice { item: i, mutable, .. } => {
                    if not mutable { throw emitError(self, container, ErrorKind::ImmutableBinding); }
                    set item = i;
                }
                else => throw emitError(self, container, ErrorKind::ExpectedIndexable),
            }


                return setNodeType(self, node, Type::U32);
            }
            throw emitError(self, node, ErrorKind::ArrayFieldUnknown(fieldName));
        }
        case Type::Slice { item, mutable } => {
        case Type::Slice { item, mutable, .. } => {
            let fieldNode = access.child;
            let fieldName = try nodeName(self, fieldNode);

            if mem::eq(fieldName, PTR_FIELD) {
                setRecordFieldIndex(self, fieldNode, 0);
                let ptrTy = Type::Pointer {
                    class: types::PointerClass::Owned,
                    target: item,
                    mutable,
                };
                return setNodeType(self, node, ptrTy);
            }

                case Type::Array(arrayInfo) => {
                    try validateArraySliceBounds(self, range, arrayInfo.length, node);
                    set item = arrayInfo.item;
                    set capacity = arrayInfo.length;
                }
                case Type::Slice { item: sliceItem, mutable } => {
                case Type::Slice { item: sliceItem, mutable, .. } => {
                    if addr.mutable and not mutable {
                        throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
                    }
                    set item = sliceItem;
                }
                else => {
                    throw emitError(self, container, ErrorKind::ExpectedIndexable);
                }
            }
            let sliceTy = Type::Slice { item, mutable: addr.mutable };
            let sliceTy = Type::Slice {
                class: types::PointerClass::Owned, item, mutable: addr.mutable,
            };
            let alloc = allocType(self, sliceTy);
            setSliceRangeInfo(self, node, SliceRangeInfo {
                itemType: item,
                mutable: addr.mutable,
                capacity,

        match addr.target.value {
            case ast::NodeValue::ArrayLit(_),
                 ast::NodeValue::ArrayRepeatLit(_) =>
            {
                let sliceTy = Type::Slice {
                    class: types::PointerClass::Owned,
                    item: arrayInfo.item,
                    mutable: addr.mutable,
                };
                return setNodeType(self, node, *allocType(self, sliceTy));
            }
            else => {}
        }
    }
    let pointerTy = Type::Pointer {
        class: types::PointerClass::Owned,
        target: allocType(self, targetTy),
        mutable: addr.mutable,
    };
    return setNodeType(self, node, pointerTy);
}

            let item = try infer(self, itemType);
            let length = try checkSizeInt(self, length);

            return Type::Array(ArrayType { item: allocType(self, item), length });
        }
        case ast::TypeSig::Slice { itemType, mutable } => {
        case ast::TypeSig::Slice { class, itemType, mutable } => {
            let item = try infer(self, itemType);
            return Type::Slice {
                class,
                item: allocType(self, item),
                mutable,
            };
        }
        case ast::TypeSig::Pointer { valueType, mutable } => {
        case ast::TypeSig::Pointer { class, valueType, mutable } => {
            let target = try infer(self, valueType);
            return Type::Pointer {
                class,
                target: allocType(self, target),
                mutable,
            };
        }
        case ast::TypeSig::Optional { valueType } => {

                throwList: &throwList[..],
                localCount: 0,
            };
            return Type::Fn(allocFnType(self, fnType));
        }
        case ast::TypeSig::TraitObject { traitName, mutable } => {
        case ast::TypeSig::TraitObject { class, traitName, mutable } => {
            let sym = try resolveNamePath(self, traitName);
            let case SymbolData::Trait(traitInfo) = sym.data
                else throw emitError(self, traitName, ErrorKind::Internal);
            setNodeSymbol(self, traitName, sym);

            return Type::TraitObject { traitInfo, mutable };
            return Type::TraitObject {
                class,
                traitInfo,
                mutable,
            };
        }
    }
}

/// Check if a type can be used for inferrence.

lib/std/lang/resolver/printer.rad +3 -3

            io::print("i32");
        }
        case super::Type::I64 => {
            io::print("i64");
        }
        case super::Type::Pointer { target, mutable } => {
        case super::Type::Pointer { target, mutable, .. } => {
            printPtrPrefix(mutable);
            printTypeBody(*target, brief);
        }
        case super::Type::Slice { item, mutable } => {
        case super::Type::Slice { item, mutable, .. } => {
            printPtrPrefix(mutable);
            io::print("[");
            printTypeBody(*item, brief);
            io::print("]");
        }

                printNominalTypeName(info);
            } else {
                printNominalType(info);
            }
        }
        case super::Type::TraitObject { traitInfo, mutable } => {
        case super::Type::TraitObject { traitInfo, mutable, .. } => {
            printPtrPrefix(mutable);
            io::print("opaque ");
            io::print(traitInfo.name);
        }
        case super::Type::Range { start, end } => {

lib/std/lang/resolver/tests.rad +2 -2

}

fn expectSliceType(ty: super::Type, mutable: bool) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Slice { item, mutable: sliceMut } = ty
    let case super::Type::Slice { item, mutable: sliceMut, .. } = ty
        else throw testing::TestError::Failed;
    try testing::expect(sliceMut == mutable);

    return *item;
}

fn expectPointerType(ty: super::Type, mutable: bool) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Pointer { target, mutable: ptrMut } = ty
    let case super::Type::Pointer { target, mutable: ptrMut, .. } = ty
        else throw testing::TestError::Failed;
    try testing::expect(ptrMut == mutable);

    return *target;
}

lib/std/lang/scanner.rad +3 -2

    // Trait-related tokens.
    Trait, Instance,

    // Type-related tokens.
    I8, I16, I32, I64, U8, U16, U32, U64,
    Opaque, Fn, Bool, Union, Record, As
    Opaque, Fn, Bool, Union, Record, As, Unsafe
}

/// A reserved keyword.
record Keyword {
    /// Keyword string.

    /// Corresponding token.
    tok: TokenKind,
}

/// Sorted keyword table for binary search.
constant KEYWORDS: [Keyword; 51] = [
constant KEYWORDS: [Keyword; 52] = [
    { name: "align", tok: TokenKind::Align },
    { name: "and", tok: TokenKind::And },
    { name: "as", tok: TokenKind::As },
    { name: "assert", tok: TokenKind::Assert },
    { name: "bool", tok: TokenKind::Bool },

    { name: "u32", tok: TokenKind::U32 },
    { name: "u64", tok: TokenKind::U64 },
    { name: "u8", tok: TokenKind::U8 },
    { name: "undefined", tok: TokenKind::Undefined },
    { name: "union", tok: TokenKind::Union },
    { name: "unsafe", tok: TokenKind::Unsafe },
    { name: "use", tok: TokenKind::Use },
    { name: "while", tok: TokenKind::While },
];

/// Describes where source code originated from.

lib/std/lang/scanner/tests.rad +5 -1

        try testing::expect(super::next(&mut s).kind == expectedKind);
    }
}

@test fn testScanKeywords() throws (testing::TestError) {
    let mut s = testScanner("nil mod not static");
    let mut s = testScanner("nil mod not static unsafe");
    let tok1: super::Token = super::next(&mut s);

    try testing::expect(tok1.kind == super::TokenKind::Nil);
    try testing::expect(tok1.source.len == 3);


    try testing::expect(tok3.source.len == 3);

    let tok4: super::Token = super::next(&mut s);
    try testing::expect(tok4.kind == super::TokenKind::Static);
    try testing::expect(tok4.source.len == 6);

    let tok5: super::Token = super::next(&mut s);
    try testing::expect(tok5.kind == super::TokenKind::Unsafe);
    try testing::expect(tok5.source.len == 6);
}

@test fn testScanVoidAsIdent() throws (testing::TestError) {
    let mut s = testScanner("void");
    let tok: super::Token = super::next(&mut s);

lib/std/lang/types.rad added +11 -0

1	+	//! Shared Radiance language types.
2	+
3	+	/// Ownership and safety class for pointer-like types.
4	+	export union PointerClass {
5	+	/// Owned pointer, eg. `*T`.
6	+	Owned,
7	+	/// Reference, borrowed pointer, eg. `&T`.
8	+	Ref,
9	+	/// Unsafe, raw pointer, eg. `*unsafe T`.
10	+	Unsafe,
11	+	}

std.lib +1 -0

lib/std/arch/rv64/asm/scanner.rad
lib/std/arch/rv64/asm/parser.rad
lib/std/arch/rv64/asm/emit.rad
lib/std/lang.rad
lib/std/lang/alloc.rad
lib/std/lang/types.rad
lib/std/lang/strings.rad
lib/std/lang/sexpr.rad
lib/std/lang/ast.rad
lib/std/lang/ast/printer.rad
lib/std/lang/scanner.rad

test/tests/builtin.size.align.rad +0 -1

    assert @alignOf(*[u16]) == 8;

    assert @sizeOf(*mut [u8]) == 16;
    assert @alignOf(*mut [u8]) == 8;


    return 0;
}

170	173		/// Array element type.
171	174		itemType: *Node,
172	175		/// Expression that evaluates to the array length.
173	176		length: *Node,
174	177		},
175		-	/// Slice type, eg. `[i32]` or `mut [i32]`.
	178	+	/// Slice type, eg. `[i32]`, `&[i32]`, or `unsafe [i32]`.
176	179		Slice {
	180	+	/// Ownership and safety class.
	181	+	class: types::PointerClass,
177	182		/// Slice element type.
178	183		itemType: *Node,
179	184		/// Whether the slice is mutable.
180	185		mutable: bool,
181	186		},
182		-	/// Pointer, eg. `i32` or `mut i32`.
	187	+	/// Pointer type, eg. `i32`, `&i32`, or `unsafe i32`.
183	188		Pointer {
	189	+	/// Ownership and safety class.
	190	+	class: types::PointerClass,
184	191		/// Pointer target type.
185	192		valueType: *Node,
186	193		/// Whether the pointer is mutable.
187	194		mutable: bool,
188	195		},

200	207		/// Whether this record has labeled fields.
201	208		labeled: bool,
202	209		},
203	210		/// Anonymous function type.
204	211		Fn(FnSig),
205		-	/// Trait object type, eg. `*opaque Allocator`.
	212	+	/// Trait object type, eg. `*opaque Allocator`, `&opaque Allocator`, or
	213	+	/// `*unsafe opaque Allocator`.
206	214		TraitObject {
	215	+	/// Ownership and safety class.
	216	+	class: types::PointerClass,
207	217		/// Trait name identifier.
208	218		traitName: *Node,
209	219		/// Whether the pointer is mutable.
210	220		mutable: bool,
211	221		},

752	762		name: *Node,
753	763		/// Receiver type node (eg. `*mut Allocator`).
754	764		receiver: *Node,
755	765		/// Function signature.
756	766		sig: FnSig,
	767	+	/// Optional declaration modifiers.
	768	+	attrs: ?Attributes,
757	769		},
758	770		/// Instance block.
759	771		InstanceDecl {
760	772		/// Trait name identifier.
761	773		traitName: *Node,

93	112		if let rt = sig.returnType {
94	113		set ret = toExpr(a, rt);
95	114		}
96	115		return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
97	116		}
98		-	case super::TypeSig::TraitObject { traitName, mutable } =>
99		-	return sexpr::list(a, "obj", &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
100		-	else sexpr::list(a, "obj", &[toExpr(a, traitName)]),
	117	+	case super::TypeSig::TraitObject { class, traitName, mutable } => {
	118	+	let head = pointerClassHead(class, "obj", "obj-ref", "unsafe-obj");
	119	+	return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
	120	+	else sexpr::list(a, head, &[toExpr(a, traitName)]);
	121	+	}
101	122		}
102	123		}
103	124
104	125		/// Convert a node slice to a slice of expressions.
105	126		fn nodeListToExprs(a: mut alloc::Arena, nodes: [super::Node]) -> [sexpr::Expr] {

111	132		set buf[i] = toExpr(a, node);
112	133		}
113	134		return buf;
114	135		}
115	136
	137	+	/// Convert optional attributes to an attribute list expression.
	138	+	fn attributesToExpr(a: *mut alloc::Arena, attrs: ?super::Attributes) -> sexpr::Expr {
	139	+	let mut exprs: *[sexpr::Expr] = &[];
	140	+	if let list = attrs {
	141	+	set exprs = nodeListToExprs(a, &list.list[..]);
	142	+	}
	143	+	return sexpr::list(a, "attrs", exprs);
	144	+	}
	145	+
116	146		/// Convert an optional node to an expression, or return placeholder.
117	147		fn toExprOpt(a: mut alloc::Arena, opt: ?super::Node) -> sexpr::Expr {
118	148		if let n = opt {
119	149		return toExpr(a, n);
120	150		}

1	1		//! Radiance language implementation.
2	2		export mod alloc;
3	3		export mod sexpr;
	4	+	export mod types;
4	5		export mod strings;
5	6		export mod scanner;
6	7		export mod ast;
7	8		export mod parser;
8	9		export mod module;

2	2		export mod printer;
3	3
4	4		use std::io;
5	5		use std::fmt;
6	6		use std::lang::alloc;
	7	+	use std::lang::types;
7	8
8	9		/// Maximum number of trait methods.
9	10		export constant MAX_TRAIT_METHODS: u32 = 8;
10	11
11	12		/// Arena for all parser allocations.

46	47		Extern = 0b100,
47	48		/// Test-only declaration attribute.
48	49		Test = 0b1000,
49	50		/// Compiler intrinsic attribute.
50	51		Intrinsic = 0b10000,
	52	+	/// Declaration may perform unsafe pointer operations.
	53	+	Unsafe = 0b100000,
51	54		}
52	55
53	56		/// Ordered collection of attribute nodes applied to a declaration.
54	57		export record Attributes {
55	58		list: mut [Node],

1	1		//! AST pretty printer using S-expression syntax.
2	2
3	3		use std::io;
4	4		use std::lang::sexpr;
5	5		use std::lang::alloc;
	6	+	use std::lang::types;
6	7
7	8		/// Return the symbol for a binary operator.
8	9		fn binOpName(op: super::BinaryOp) -> *[u8] {
9	10		match op {
10	11		case super::BinaryOp::Add => return "+",

66	67		else => panic,
67	68		}
68	69		}
69	70		}
70	71
	72	+	/// Return the S-expression head for a pointer class.
	73	+	fn pointerClassHead(
	74	+	class: types::PointerClass,
	75	+	ownedHead: *[u8],
	76	+	refHead: *[u8],
	77	+	unsafeHead: *[u8],
	78	+	) -> *[u8] {
	79	+	match class {
	80	+	case types::PointerClass::Owned => return ownedHead,
	81	+	case types::PointerClass::Ref => return refHead,
	82	+	case types::PointerClass::Unsafe => return unsafeHead,
	83	+	}
	84	+	}
	85	+
71	86		/// Convert a type signature to an S-expression.
72	87		fn typeSigToExpr(a: *mut alloc::Arena, sig: super::TypeSig) -> sexpr::Expr {
73	88		match sig {
74	89		case super::TypeSig::Void => return sexpr::sym("void"),
75	90		case super::TypeSig::Opaque => return sexpr::sym("opaque"),
76	91		case super::TypeSig::Bool => return sexpr::sym("bool"),
77	92		case super::TypeSig::Integer { width, sign } => return sexpr::sym(intTypeName(width, sign)),
78	93		case super::TypeSig::Array { itemType, length } =>
79	94		return sexpr::list(a, "array", &[toExpr(a, itemType), toExpr(a, length)]),
80		-	case super::TypeSig::Slice { itemType, mutable } =>
81		-	return sexpr::list(a, "slice", &[sexpr::sym("mut"), toExpr(a, itemType)]) if mutable
82		-	else sexpr::list(a, "slice", &[toExpr(a, itemType)]),
83		-	case super::TypeSig::Pointer { valueType, mutable } =>
84		-	return sexpr::list(a, "ptr", &[sexpr::sym("mut"), toExpr(a, valueType)]) if mutable
85		-	else sexpr::list(a, "ptr", &[toExpr(a, valueType)]),
	95	+	case super::TypeSig::Slice { class, itemType, mutable } => {
	96	+	let head = pointerClassHead(class, "slice", "slice-ref", "unsafe-slice");
	97	+	return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, itemType)]) if mutable
	98	+	else sexpr::list(a, head, &[toExpr(a, itemType)]);
	99	+	}
	100	+	case super::TypeSig::Pointer { class, valueType, mutable } => {
	101	+	let head = pointerClassHead(class, "ptr", "ref", "unsafe-ptr");
	102	+	return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, valueType)]) if mutable
	103	+	else sexpr::list(a, head, &[toExpr(a, valueType)]);
	104	+	}
86	105		case super::TypeSig::Optional { valueType } =>
87	106		return sexpr::list(a, "?", &[toExpr(a, valueType)]),
88	107		case super::TypeSig::Nominal(name) => return toExpr(a, name),
89	108		case super::TypeSig::Record { fields, .. } =>
90	109		return sexpr::list(a, "record", nodeListToExprs(a, &fields[..])),

305	335		case super::Attribute::Export => return sexpr::sym("@export"),
306	336		case super::Attribute::Default => return sexpr::sym("@default"),
307	337		case super::Attribute::Extern => return sexpr::sym("@extern"),
308	338		case super::Attribute::Test => return sexpr::sym("@test"),
309	339		case super::Attribute::Intrinsic => return sexpr::sym("@intrinsic"),
	340	+	case super::Attribute::Unsafe => return sexpr::sym("@unsafe"),
310	341		}
311	342		}
312	343		case super::NodeValue::Try(t) => {
313	344		let mut head = "try";
314	345		if t.shouldPanic { set head = "try!"; }

444	475		case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
445	476		let children = nodeListToExprs(a, &methods[..]);
446	477		let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
447	478		return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
448	479		}
449		-	case super::NodeValue::TraitMethodSig { name, receiver, sig } => {
	480	+	case super::NodeValue::TraitMethodSig { name, receiver, sig, attrs } => {
450	481		let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
451	482		let ret = toExprOrNull(a, sig.returnType);
452		-	return sexpr::list(a, "methodSig", &[toExpr(a, receiver), toExpr(a, name), params, ret]);
	483	+	let attributes = attributesToExpr(a, attrs);
	484	+	return sexpr::list(
	485	+	a,
	486	+	"methodSig",
	487	+	&[attributes, toExpr(a, receiver), toExpr(a, name), params, ret],
	488	+	);
453	489		}
454	490		case super::NodeValue::InstanceDecl { traitName, targetType, methods } => {
455	491		let children = nodeListToExprs(a, &methods[..]);
456	492		return sexpr::block(a, "instance", &[toExpr(a, traitName), toExpr(a, targetType)], children);
457	493		}
458		-	case super::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, .. } => {
	494	+	case super::NodeValue::MethodDecl {
	495	+	name, receiverName, receiverType, sig, body, attrs,
	496	+	} => {
459	497		let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
460	498		let ret = toExprOrNull(a, sig.returnType);
461		-	return sexpr::block(a, "method", &[toExpr(a, receiverType), toExpr(a, receiverName), toExpr(a, name), params, ret], &[toExpr(a, body)]);
	499	+	let attributes = attributesToExpr(a, attrs);
	500	+	return sexpr::block(
	501	+	a,
	502	+	"method",
	503	+	&[
	504	+	attributes,
	505	+	toExpr(a, receiverType),
	506	+	toExpr(a, receiverName),
	507	+	toExpr(a, name),
	508	+	params,
	509	+	ret,
	510	+	],
	511	+	&[toExpr(a, body)],
	512	+	);
462	513		}
463	514		else => return sexpr::sym("?"),
464	515		}
465	516		}
466	517

88	88		//! il::Data
89	89		//!
90	90		use std::fmt;
91	91		use std::io;
92	92		use std::lang::alloc;
	93	+	use std::lang::types;
93	94		use std::mem;
94	95		use std::lang::ast;
95	96		use std::lang::il;
96	97		use std::lang::module;
97	98		use std::lang::resolver;

4220	4221		fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
4221	4222		match optType {
4222	4223		case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
4223	4224		return il::Val::Imm(0);
4224	4225		}
4225		-	case resolver::Type::Optional(resolver::Type::Slice { item, mutable }) => {
	4226	+	case resolver::Type::Optional(resolver::Type::Slice { item, mutable, .. }) => {
4226	4227		return try buildSliceValue(self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0));
4227	4228		}
4228	4229		case resolver::Type::Optional(inner) => {
4229	4230		let valOffset = resolver::getOptionalValOffset(*inner) as i32;
4230	4231		return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);

4254	4255		mutable: bool,
4255	4256		ptrVal: il::Val,
4256	4257		lenVal: il::Val,
4257	4258		capVal: il::Val
4258	4259		) -> il::Val throws (LowerError) {
4259		-	let sliceType = resolver::Type::Slice { item: elemTy, mutable };
	4260	+	let sliceType = resolver::Type::Slice {
	4261	+	class: types::PointerClass::Owned, item: elemTy, mutable,
	4262	+	};
4260	4263		let dst = try emitReserve(self, sliceType);
4261		-	let ptrTy = resolver::Type::Pointer { target: elemTy, mutable };
	4264	+	let ptrTy = resolver::Type::Pointer {
	4265	+	class: types::PointerClass::Owned, target: elemTy, mutable,
	4266	+	};
4262	4267
4263	4268		try emitStore(self, dst, SLICE_PTR_OFFSET, ptrTy, ptrVal);
4264	4269		try emitStore(self, dst, SLICE_LEN_OFFSET, resolver::Type::U32, lenVal);
4265	4270		try emitStore(self, dst, SLICE_CAP_OFFSET, resolver::Type::U32, capVal);
4266	4271

4444	4449		mutable: bool,
4445	4450		a: il::Reg,
4446	4451		b: il::Reg,
4447	4452		offset: i32
4448	4453		) -> il::Val throws (LowerError) {
4449		-	let ptrTy = resolver::Type::Pointer { target: elemTy, mutable };
	4454	+	let ptrTy = resolver::Type::Pointer {
	4455	+	class: types::PointerClass::Owned, target: elemTy, mutable,
	4456	+	};
4450	4457		let ptrEq = try emitEqAtOffset(self, a, b, offset + SLICE_PTR_OFFSET, ptrTy);
4451	4458		let lenEq = try emitEqAtOffset(self, a, b, offset + SLICE_LEN_OFFSET, resolver::Type::U32);
4452	4459
4453	4460		return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, ptrEq, lenEq);
4454	4461		}

4693	4700		a: il::Reg,
4694	4701		b: il::Reg,
4695	4702		offset: i32
4696	4703		) -> il::Val throws (LowerError) {
4697	4704		match typ {
4698		-	case resolver::Type::Optional(resolver::Type::Slice { item, mutable }) => {
	4705	+	case resolver::Type::Optional(resolver::Type::Slice { item, mutable, .. }) => {
4699	4706		// Optional slices use null pointer optimization.
4700	4707		return try lowerSliceEq(self, item, mutable, a, b, offset);
4701	4708		}
4702	4709		case resolver::Type::Optional(inner) => {
4703	4710		return try lowerOptionalEq(self, *inner, a, b, offset);
4704	4711		}
4705		-	case resolver::Type::Slice { item, mutable } =>
	4712	+	case resolver::Type::Slice { item, mutable, .. } =>
4706	4713		return try lowerSliceEq(self, item, mutable, a, b, offset),
4707	4714		case resolver::Type::Array(arr) =>
4708	4715		return try lowerArrayEq(self, arr, a, b, offset),
4709	4716		case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) =>
4710	4717		return try lowerRecordEq(self, recInfo, a, b, offset),

5058	5065		self: *mut FnLowerer,
5059	5066		sliceNode: *ast::Node,
5060	5067		arrayNode: *ast::Node
5061	5068		) -> il::Val throws (LowerError) {
5062	5069		let sliceTy = try typeOf(self, sliceNode);
5063		-	let case resolver::Type::Slice { item, mutable } = sliceTy else {
	5070	+	let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
5064	5071		throw LowerError::UnexpectedType(&sliceTy);
5065	5072		};
5066	5073		let arrayTy = try typeOf(self, arrayNode);
5067	5074		let case resolver::Type::Array(arrayInfo) = arrayTy else {
5068	5075		throw LowerError::ExpectedArray;

6140	6147		/// String literals are stored as global data and the result is a slice
6141	6148		/// pointing to the data with the appropriate length.
6142	6149		fn lowerStringLit(self: mut FnLowerer, node: ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
6143	6150		// Get the slice type from the node.
6144	6151		let sliceTy = try typeOf(self, node);
6145		-	let case resolver::Type::Slice { item, mutable } = sliceTy else {
	6152	+	let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
6146	6153		throw LowerError::ExpectedSliceOrArray;
6147	6154		};
6148	6155		// Build the string data value.
6149	6156		let ptr = try! alloc::alloc(
6150	6157		self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)

6172	6179		fn lowerSliceOf(self: mut FnLowerer, node: ast::Node, args: mut [ast::Node]) -> il::Val throws (LowerError) {
6173	6180		if args.len <> 2 and args.len <> 3 {
6174	6181		throw LowerError::InvalidArgCount;
6175	6182		}
6176	6183		let sliceTy = try typeOf(self, node);
6177		-	let case resolver::Type::Slice { item, mutable } = sliceTy else {
	6184	+	let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
6178	6185		throw LowerError::ExpectedSliceOrArray;
6179	6186		};
6180	6187		let ptrVal = try lowerExpr(self, args[0]);
6181	6188		let lenVal = try lowerExpr(self, args[1]);
6182	6189		let mut capVal = lenVal;

779	780		));
780	781		}
781	782		throw failParsing(p, "expected assignment after `set`");
782	783		}
783	784
784		-	/// Parse leading attributes attached to the next declaration statement.
	785	+	/// Parse leading attributes and declaration modifiers.
785	786		fn parseAttributes(p: *mut Parser) -> ?ast::Attributes {
786	787		let mut attrs = ast::nodeSlice(p.arena, 4);
787	788
788	789		if let attr = tryParseAnnotation(p) {
789	790		attrs.append(attr, p.allocator);
790	791		}
791	792		if consume(p, scanner::TokenKind::Export) {
792		-	let attrNode = nodeAttribute(p, ast::Attribute::Export);
793		-	attrs.append(attrNode, p.allocator);
	793	+	attrs.append(nodeAttribute(p, ast::Attribute::Export), p.allocator);
	794	+	}
	795	+	if consume(p, scanner::TokenKind::Unsafe) {
	796	+	attrs.append(nodeAttribute(p, ast::Attribute::Unsafe), p.allocator);
794	797		}
795	798		if attrs.len > 0 {
796	799		return ast::Attributes { list: attrs };
797	800		}
798	801		return nil;

831	834		{
832	835		// TODO: Why is `parseStmt` checking for attributes?
833	836		// We should have a `parseDecl` which is top-level, and `parseStmt` which
834	837		// is inside functions.
835	838		let attrs = parseAttributes(p);
836		-	if attrs <> nil {
	839	+	if let list = attrs {
	840	+	if ast::attributesContains(&list, ast::Attribute::Unsafe)
	841	+	and p.current.kind <> scanner::TokenKind::Fn
	842	+	and p.current.kind <> scanner::TokenKind::Mod
	843	+	{
	844	+	throw failParsing(p, "`unsafe` is only allowed on functions and modules");
	845	+	}
837	846		let allowed: bool =
838	847		p.current.kind == scanner::TokenKind::Fn or
839	848		p.current.kind == scanner::TokenKind::Union or
840	849		p.current.kind == scanner::TokenKind::Record or
841	850		p.current.kind == scanner::TokenKind::Mod or

1856	1865		return node(p, ast::NodeValue::FnDecl(
1857	1866		ast::FnDecl { name, sig, body, attrs: fnAttrs }
1858	1867		));
1859	1868		}
1860	1869
1861		-	/// Parse a pointer or slice type.
1862		-	fn parsePointerType(p: mut Parser) -> ast::Node
1863		-	throws (ParseError)
1864		-	{
1865		-	try expect(p, scanner::TokenKind::Star, "expected `*`");
	1870	+	/// Parse a pointer-like type after its ownership prefix.
	1871	+	fn parsePointerLikeType(
	1872	+	p: *mut Parser,
	1873	+	class: types::PointerClass,
	1874	+	) -> *ast::Node throws (ParseError) {
1866	1875		let mutable = consume(p, scanner::TokenKind::Mut);
1867	1876
1868	1877		if consume(p, scanner::TokenKind::LBracket) {
1869	1878		let itemType = try parseType(p);
1870	1879		try expect(p, scanner::TokenKind::RBracket, "expected `]` after slice element type");
1871	1880
1872	1881		return node(p, ast::NodeValue::TypeSig(
1873		-	ast::TypeSig::Slice { itemType, mutable }
	1882	+	ast::TypeSig::Slice { class, itemType, mutable }
1874	1883		));
1875	1884		}
1876		-	// Check for `opaque Trait` or `mut opaque Trait`.
	1885	+	// Check for an opaque trait object.
1877	1886		if consume(p, scanner::TokenKind::Opaque) {
1878	1887		if check(p, scanner::TokenKind::Ident) or check(p, scanner::TokenKind::Super) {
1879	1888		let traitName = try parseTypePath(p);
1880	1889		return node(p, ast::NodeValue::TypeSig(
1881		-	ast::TypeSig::TraitObject { traitName, mutable }
	1890	+	ast::TypeSig::TraitObject { class, traitName, mutable }
1882	1891		));
1883	1892		}
1884		-	// Plain `*opaque`.
	1893	+	// Plain opaque target.
	1894	+	let valueType = node(p, ast::NodeValue::TypeSig(ast::TypeSig::Opaque));
1885	1895		return node(p, ast::NodeValue::TypeSig(
1886		-	ast::TypeSig::Pointer {
1887		-	valueType: node(p, ast::NodeValue::TypeSig(ast::TypeSig::Opaque)),
1888		-	mutable,
1889		-	}
	1896	+	ast::TypeSig::Pointer { class, valueType, mutable }
1890	1897		));
1891	1898		}
1892	1899		let valueType = try parseType(p);
1893	1900
1894	1901		return node(p, ast::NodeValue::TypeSig(
1895		-	ast::TypeSig::Pointer { valueType, mutable }
	1902	+	ast::TypeSig::Pointer { class, valueType, mutable }
1896	1903		));
1897	1904		}
1898	1905
1899	1906		/// Parse an array type.
1900	1907		fn parseArrayType(p: mut Parser) -> ast::Node

1945	1952		return node(p, ast::NodeValue::TypeSig(
1946	1953		ast::TypeSig::Optional { valueType }
1947	1954		));
1948	1955		}
1949	1956		case scanner::TokenKind::Star => {
1950		-	return try parsePointerType(p);
	1957	+	advance(p);
	1958	+	let class = types::PointerClass::Unsafe
	1959	+	if consume(p, scanner::TokenKind::Unsafe)
	1960	+	else types::PointerClass::Owned;
	1961	+	return try parsePointerLikeType(p, class);
	1962	+	}
	1963	+	case scanner::TokenKind::Amp => {
	1964	+	advance(p);
	1965	+	return try parsePointerLikeType(p, types::PointerClass::Ref);
1951	1966		}
1952	1967		case scanner::TokenKind::LBracket => {
1953	1968		return try parseArrayType(p);
1954	1969		}
1955	1970		case scanner::TokenKind::Super, scanner::TokenKind::Ident => {

2252	2267		/// Parse a trait method signature.
2253	2268		/// Syntax: `fn (*Trait) fnord(<params>) -> ReturnType;`
2254	2269		fn parseTraitMethodSig(p: mut Parser) -> ast::Node
2255	2270		throws (ParseError)
2256	2271		{
	2272	+	let attrs = parseAttributes(p);
2257	2273		try expect(p, scanner::TokenKind::Fn, "expected `fn`");
2258	2274		try expect(p, scanner::TokenKind::LParen, "expected `(` before receiver");
2259	2275
2260	2276		let receiver = try parseType(p);
2261	2277

2263	2279
2264	2280		let name = try parseIdent(p, "expected method name");
2265	2281		let sig = try parseFnTypeSig(p);
2266	2282		try expect(p, scanner::TokenKind::Semicolon, "expected `;` after method signature");
2267	2283
2268		-	return node(p, ast::NodeValue::TraitMethodSig { name, receiver, sig });
	2284	+	return node(p, ast::NodeValue::TraitMethodSig { name, receiver, sig, attrs });
2269	2285		}
2270	2286
2271	2287		/// Parse an instance block.
2272	2288		/// Syntax: `instance Trait for Type { fn (t: *mut Type) fnord(..) {..} }`
2273	2289		///

2281	2297		try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
2282	2298		let targetType = try parseTypePath(p);
2283	2299		try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");
2284	2300
2285	2301		let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);
	2302	+
2286	2303		while not check(p, scanner::TokenKind::RBrace) and
2287	2304		not check(p, scanner::TokenKind::Eof)
2288	2305		{
	2306	+	let attrs = parseAttributes(p);
2289	2307		try expect(p, scanner::TokenKind::Fn, "expected `fn`");
2290		-	let method = try parseMethodDecl(p, nil);
	2308	+	let method = try parseMethodDecl(p, attrs);
2291	2309
2292	2310		methods.append(method, p.allocator);
2293	2311		}
2294	2312		try expect(p, scanner::TokenKind::RBrace, "expected `}` after instance methods");
2295	2313

2	2
3	3		use std::mem;
4	4		use std::fmt;
5	5		use std::testing;
6	6		use std::lang::ast;
	7	+	use std::lang::types;
	8	+	use std::lang::alloc;
	9	+	use std::lang::sexpr;
	10	+	use std::lang::ast::printer;
7	11		use std::lang::scanner;
8	12		use std::lang::strings;
9	13
10	14		/// Unified arena size.
11	15		constant ARENA_SIZE: u32 = 2097152;

783	787		else throw testing::TestError::Failed;
784	788
785	789		try expectIntType(opt, 4, ast::Signedness::Signed);
786	790		}
787	791
788		-	/// Test parsing a pointer type, including `mut`.
789		-	@test fn testParseTypePointer() throws (testing::TestError) {
790		-	let node = try! parseTypeStr("*mut i32");
	792	+	/// Parse an `i32` pointer type and verify its class and mutability.
	793	+	fn expectI32Pointer(
	794	+	source: *[u8],
	795	+	class: types::PointerClass,
	796	+	mutable: bool,
	797	+	) throws (testing::TestError) {
	798	+	let node = try! parseTypeStr(source);
791	799		let case ast::NodeValue::TypeSig(sig) = node.value
792	800		else throw testing::TestError::Failed;
793		-	let case ast::TypeSig::Pointer { valueType, mutable } = sig
794		-	else throw testing::TestError::Failed;
	801	+	let case ast::TypeSig::Pointer {
	802	+	class: actualClass, valueType, mutable: actualMutable,
	803	+	} = sig else throw testing::TestError::Failed;
795	804
	805	+	assert actualClass == class;
796	806		try expectIntType(valueType, 4, ast::Signedness::Signed);
797		-	try testing::expect(mutable);
	807	+	assert actualMutable == mutable;
	808	+	}
	809	+
	810	+	/// Test parsing a mutable owned pointer.
	811	+	@test fn testParseTypePointer() throws (testing::TestError) {
	812	+	try expectI32Pointer("*mut i32", types::PointerClass::Owned, true);
798	813		}
799	814
800		-	/// Test parsing an immutable pointer type.
	815	+	/// Test parsing an immutable owned pointer.
801	816		@test fn testParseTypePointerImmutable() throws (testing::TestError) {
802		-	let node = try! parseTypeStr("*i32");
803		-	let case ast::NodeValue::TypeSig(sig) = node.value
804		-	else throw testing::TestError::Failed;
805		-	let case ast::TypeSig::Pointer { valueType, mutable } = sig
806		-	else throw testing::TestError::Failed;
	817	+	try expectI32Pointer("*i32", types::PointerClass::Owned, false);
	818	+	}
807	819
808		-	try expectIntType(valueType, 4, ast::Signedness::Signed);
809		-	try testing::expect(not mutable);
	820	+	/// Test parsing immutable and mutable references.
	821	+	@test fn testParseTypeRef() throws (testing::TestError) {
	822	+	try expectI32Pointer("&i32", types::PointerClass::Ref, false);
	823	+	try expectI32Pointer("&mut i32", types::PointerClass::Ref, true);
	824	+	}
	825	+
	826	+	/// Test parsing immutable and mutable unsafe pointers.
	827	+	@test fn testParseTypeUnsafePointer() throws (testing::TestError) {
	828	+	try expectI32Pointer("*unsafe i32", types::PointerClass::Unsafe, false);
	829	+	try expectI32Pointer("*unsafe mut i32", types::PointerClass::Unsafe, true);
810	830		}
811	831
812	832		/// Test parsing a slice type.
813	833		@test fn testParseTypeSlice() throws (testing::TestError) {
814	834		let node = try! parseTypeStr("*[u8]");
815	835		let case ast::NodeValue::TypeSig(sig) = node.value
816	836		else throw testing::TestError::Failed;
817		-	let case ast::TypeSig::Slice { itemType, mutable } = sig
	837	+	let case ast::TypeSig::Slice { class, itemType, mutable } = sig
818	838		else throw testing::TestError::Failed;
819	839
	840	+	assert class == types::PointerClass::Owned;
820	841		try expectIntType(itemType, 1, ast::Signedness::Unsigned);
821		-	try testing::expect(not mutable);
	842	+	assert not mutable;
822	843		}
823	844
824	845		/// Test parsing a mutable slice type.
825	846		@test fn testParseTypeSliceMutable() throws (testing::TestError) {
826	847		let node = try! parseTypeStr("*mut [u8]");
827	848		let case ast::NodeValue::TypeSig(sig) = node.value
828	849		else throw testing::TestError::Failed;
829		-	let case ast::TypeSig::Slice { itemType, mutable } = sig
	850	+	let case ast::TypeSig::Slice { class, itemType, mutable } = sig
830	851		else throw testing::TestError::Failed;
831	852
	853	+	assert class == types::PointerClass::Owned;
832	854		try expectIntType(itemType, 1, ast::Signedness::Unsigned);
833		-	try testing::expect(mutable);
	855	+	assert mutable;
	856	+	}
	857	+
	858	+	/// Test parsing reference and unsafe slice classes.
	859	+	@test fn testParseTypeSliceClasses() throws (testing::TestError) {
	860	+	let refNode = try! parseTypeStr("&[u8]");
	861	+	let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
	862	+	class: refClass, ..
	863	+	}) = refNode.value else throw testing::TestError::Failed;
	864	+	assert refClass == types::PointerClass::Ref;
	865	+
	866	+	let unsafeNode = try! parseTypeStr("*unsafe [u8]");
	867	+	let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
	868	+	class: unsafeClass, ..
	869	+	}) = unsafeNode.value else throw testing::TestError::Failed;
	870	+	assert unsafeClass == types::PointerClass::Unsafe;
	871	+	}
	872	+
	873	+	/// Test parsing trait object pointer classes.
	874	+	@test fn testParseTypeTraitObjectClasses() throws (testing::TestError) {
	875	+	let ownedNode = try! parseTypeStr("*opaque Read");
	876	+	let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
	877	+	class: ownedClass, ..
	878	+	}) = ownedNode.value else throw testing::TestError::Failed;
	879	+	assert ownedClass == types::PointerClass::Owned;
	880	+
	881	+	let refNode = try! parseTypeStr("&opaque Read");
	882	+	let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
	883	+	class: refClass, ..
	884	+	}) = refNode.value else throw testing::TestError::Failed;
	885	+	assert refClass == types::PointerClass::Ref;
	886	+
	887	+	let unsafeNode = try! parseTypeStr("*unsafe opaque Read");
	888	+	let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
	889	+	class: unsafeClass, ..
	890	+	}) = unsafeNode.value else throw testing::TestError::Failed;
	891	+	assert unsafeClass == types::PointerClass::Unsafe;
834	892		}
835	893
836	894		/// Test parsing an array type.
837	895		@test fn testParseTypeArray() throws (testing::TestError) {
838	896		let node = try! parseTypeStr("[i32; 4]");

964	1022		try expectIntType(param0, 4, ast::Signedness::Signed);
965	1023
966	1024		let param1 = sig.params[1];
967	1025		let case ast::NodeValue::TypeSig(p1) = param1.value
968	1026		else throw testing::TestError::Failed;
969		-	let case ast::TypeSig::Pointer { valueType: ptrTarget, mutable: _ } = p1
	1027	+	let case ast::TypeSig::Pointer { valueType: ptrTarget, .. } = p1
970	1028		else throw testing::TestError::Failed;
971	1029		try expectIntType(ptrTarget, 1, ast::Signedness::Unsigned);
972	1030
973	1031		try testing::expect(sig.returnType <> nil);
974	1032		}

1071	1129		let mut parser = super::mkParser(scanner::SourceLoc::String, "void", &mut arena, &mut STRING_POOL);
1072	1130		super::advance(&mut parser);
1073	1131		try testing::expect(super::check(&parser, scanner::TokenKind::Ident));
1074	1132		}
1075	1133
	1134	+	/// Test parsing the unsafe function modifier.
	1135	+	@test fn testParseUnsafeFnDecl() throws (testing::TestError) {
	1136	+	let node = try! parseStmtStr("unsafe fn run() {}");
	1137	+	let case ast::NodeValue::FnDecl(decl) = node.value
	1138	+	else throw testing::TestError::Failed;
	1139	+	let attrs = decl.attrs
	1140	+	else throw testing::TestError::Failed;
	1141	+
	1142	+	try testing::expect(attrs.list.len == 1);
	1143	+	try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Unsafe));
	1144	+	}
	1145	+
	1146	+	/// Test rejecting `unsafe` on declarations where it has no semantics.
	1147	+	@test fn testParseUnsafeUnsupportedDecl() throws (testing::TestError) {
	1148	+	let recordDecl: ?*ast::Node = try? parseStmtStr("unsafe record R {}");
	1149	+	try testing::expect(recordDecl == nil);
	1150	+	let constDecl: ?*ast::Node = try? parseStmtStr("unsafe constant X = 1;");
	1151	+	try testing::expect(constDecl == nil);
	1152	+	}
	1153	+
	1154	+	/// Test `unsafe` on the other declaration forms that support it.
	1155	+	@test fn testParseUnsafeMethodAndModule() throws (testing::TestError) {
	1156	+	let moduleNode = try! parseStmtStr("unsafe mod io;");
	1157	+	let case ast::NodeValue::Mod(moduleDecl) = moduleNode.value
	1158	+	else throw testing::TestError::Failed;
	1159	+	let moduleAttrs = moduleDecl.attrs else throw testing::TestError::Failed;
	1160	+	assert ast::attributesContains(&moduleAttrs, ast::Attribute::Unsafe);
	1161	+
	1162	+	let instanceNode = try! parseStmtStr(
	1163	+	"instance Read for Value { unsafe fn (value: &Value) get() {} }"
	1164	+	);
	1165	+	let case ast::NodeValue::InstanceDecl { methods, .. } = instanceNode.value
	1166	+	else throw testing::TestError::Failed;
	1167	+	try testing::expect(methods.len == 1);
	1168	+	let case ast::NodeValue::MethodDecl { attrs, .. } = methods[0].value
	1169	+	else throw testing::TestError::Failed;
	1170	+	let methodAttrs = attrs else throw testing::TestError::Failed;
	1171	+	assert ast::attributesContains(&methodAttrs, ast::Attribute::Unsafe);
	1172	+
	1173	+	let mut printStorage: [u8; 4096] = undefined;
	1174	+	let mut printArena = alloc::new(&mut printStorage[..]);
	1175	+	let methodExpr = printer::toExpr(&mut printArena, methods[0]);
	1176	+	let case sexpr::Expr::Block { items: methodItems, .. } = methodExpr
	1177	+	else throw testing::TestError::Failed;
	1178	+	let case sexpr::Expr::List {
	1179	+	head: methodAttrsHead, tail: printedMethodAttrs, ..
	1180	+	} = methodItems[0] else throw testing::TestError::Failed;
	1181	+	assert mem::eq(methodAttrsHead, "attrs");
	1182	+	let case sexpr::Expr::Sym(methodAttr) = printedMethodAttrs[0]
	1183	+	else throw testing::TestError::Failed;
	1184	+	assert mem::eq(methodAttr, "@unsafe");
	1185	+
	1186	+	let traitNode = try! parseStmtStr(
	1187	+	"trait Read { unsafe fn (&Read) get(); }"
	1188	+	);
	1189	+	let case ast::NodeValue::TraitDecl { methods: traitMethods, .. } = traitNode.value
	1190	+	else throw testing::TestError::Failed;
	1191	+	let case ast::NodeValue::TraitMethodSig {
	1192	+	attrs: traitAttrs, ..
	1193	+	} = traitMethods[0].value else throw testing::TestError::Failed;
	1194	+	let traitMethodAttrs = traitAttrs else throw testing::TestError::Failed;
	1195	+	assert ast::attributesContains(&traitMethodAttrs, ast::Attribute::Unsafe);
	1196	+
	1197	+	let traitMethodExpr = printer::toExpr(&mut printArena, traitMethods[0]);
	1198	+	let case sexpr::Expr::List { tail: traitMethodItems, .. } = traitMethodExpr
	1199	+	else throw testing::TestError::Failed;
	1200	+	let case sexpr::Expr::List {
	1201	+	head: traitAttrsHead, tail: printedTraitAttrs, ..
	1202	+	} = traitMethodItems[0] else throw testing::TestError::Failed;
	1203	+	assert mem::eq(traitAttrsHead, "attrs");
	1204	+	let case sexpr::Expr::Sym(traitAttr) = printedTraitAttrs[0]
	1205	+	else throw testing::TestError::Failed;
	1206	+	assert mem::eq(traitAttr, "@unsafe");
	1207	+	}
	1208	+
1076	1209		/// Test parsing a function declaration with attributes.
1077	1210		@test fn testParseFnDeclAttributes() throws (testing::TestError) {
1078	1211		let node = try! parseStmtStr("export fn run();");
1079	1212		let case ast::NodeValue::FnDecl(decl) = node.value
1080	1213		else throw testing::TestError::Failed;

1164	1297		@test fn testParseTypeBool() throws (testing::TestError) {
1165	1298		let node = try! parseTypeStr("bool");
1166	1299		try expectType(node, ast::TypeSig::Bool);
1167	1300		}
1168	1301
1169		-
1170	1302		/// Test parsing an unsigned integer type.
1171	1303		@test fn testParseTypeUnsigned() throws (testing::TestError) {
1172	1304		let node = try! parseTypeStr("u8");
1173	1305		try expectType(node, ast::TypeSig::Integer {
1174	1306		width: 1,

2081	2213		try expectIdent(access.child, "field");
2082	2214		}
2083	2215		}
2084	2216
2085	2217		/// Test parsing reference (address-of) expressions.
2086		-	@test fn testParseReferences() throws (testing::TestError) {
	2218	+	@test fn testParseRefs() throws (testing::TestError) {
2087	2219		{
2088	2220		let refExpr = try! parseExprStr("&foo");
2089	2221		let case ast::NodeValue::AddressOf(refNode) = refExpr.value
2090	2222		else throw testing::TestError::Failed;
2091	2223		try testing::expect(refNode.mutable == false);

14	14		// TODO: Have different types for positional vs. named field records.
15	15
16	16		use std::mem;
17	17		use std::io;
18	18		use std::lang::alloc;
	19	+	use std::lang::types;
19	20		use std::lang::ast;
20	21		use std::lang::parser;
21	22		use std::lang::module;
22	23
23	24		/// Maximum number of diagnostics recorded.

276	277		/// Range types, eg. `start..end`.
277	278		Range {
278	279		start: ?*Type,
279	280		end: ?*Type,
280	281		},
281		-	/// Eg. `*T`.
	282	+	/// Pointer-like address.
282	283		Pointer {
	284	+	class: types::PointerClass,
283	285		target: *Type,
284	286		mutable: bool,
285	287		},
286		-	/// Eg. `*[i32]`.
	288	+	/// Pointer-like slice.
287	289		Slice {
	290	+	class: types::PointerClass,
288	291		item: *Type,
289	292		mutable: bool,
290	293		},
291	294		/// Eg. `[i32; 32]`.
292	295		Array(ArrayType),