/// Method definition nodes ([`MethodDecl`]).

    /// Method definition with a receiver.

    /// Used both inside `instance` blocks and as standalone methods.

    MethodDecl {

        /// Optional attribute list.

        attrs: ?Attributes,

        case super::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, .. } => {

            case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, .. } => {

                if let f = try lowerMethodDecl(low, node, name, receiverName, sig, body) {

                    low.fns.append(f, low.allocator);

                }

            }

        let case ast::NodeValue::MethodDecl {

            name, receiverName, receiverType, sig, body, ..

        let func = try lowerMethod(self, methodNode, qualName, receiverName, sig, body)

            else continue;

/// Lower a method node into an IL function with the given qualified name.

/// Shared by both instance methods and standalone methods.

fn lowerMethod(

    self: *mut Lowerer,

    node: *ast::Node,

    qualName: *[u8],

    receiverName: *ast::Node,

    sig: ast::FnSig,

    body: *ast::Node,

) -> ?*il::Fn throws (LowerError) {

    let data = resolver::nodeData(self.resolver, node);

    let case resolver::Type::Fn(fnType) = data.ty else {

        throw LowerError::ExpectedFunction;

    };

    let sym = data.sym else throw LowerError::MissingSymbol(node);

    registerFnSym(self, sym, qualName);

    let mut fnLow = fnLowerer(self, node, fnType, qualName);

    if requiresReturnParam(fnType) {

        fnLow.returnReg = nextReg(&mut fnLow);

    }

    let lowParams = try lowerParams(&mut fnLow, *fnType, sig.params, receiverName);

    let func = try! alloc::alloc(self.arena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;

    *func = il::Fn {

        name: qualName,

        params: lowParams,

        returnType: ilType(self, *fnType.returnType),

        isExtern: false,

        isLeaf: true,

        blocks: &[],

    };

    if fnType.throwList.len > 0 {

        func.returnType = il::Type::W64;

    }

    func.blocks = try lowerFnBody(&mut fnLow, body);

    func.isLeaf = fnLow.isLeaf;

    return func;

}

/// Lower a standalone method declaration.

/// Produces a function with qualified name `Type::method`.

fn lowerMethodDecl(

    self: *mut Lowerer,

    node: *ast::Node,

    name: *ast::Node,

    receiverName: *ast::Node,

    sig: ast::FnSig,

    body: *ast::Node,

) -> ?*il::Fn throws (LowerError) {

    let sym = resolver::nodeData(self.resolver, node).sym

        else throw LowerError::MissingSymbol(node);

    let case ast::NodeValue::Ident(mName) = name.value

        else throw LowerError::ExpectedIdentifier;

    let me = resolver::findMethodBySymbol(self.resolver, sym)

        else throw LowerError::MissingMetadata;

    let qualName = instanceMethodName(self, nil, me.concreteTypeName, mName);

    return try lowerMethod(self, node, qualName, receiverName, sig, body);

}

    // Check for trait method dispatch or standalone method call.

    let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;

    } = callNodeExtra {

    } else if let case resolver::NodeExtra::MethodCall { method } = callNodeExtra {

        resVal = try lowerMethodCall(self, t.expr, callExpr, method);

    // Check for standalone method call.

    if let case resolver::NodeExtra::MethodCall { method } = nodeData {

        return try lowerMethodCall(self, node, call, method);

    }

    // Build args: optional return param slot + data pointer (receiver) + user args.

    let argOffset: u32 = 1 if requiresReturnParam(methodFnType) else 0;

    return try emitCallValue(self, il::Val::Reg(fnPtrReg), methodFnType, args);

}

/// Emit a function call with return-parameter and small-aggregate handling.

///

/// All call lowering paths (regular, trait method, standalone method) converge

/// here after preparing the callee value, function type, and argument array.

/// The `args` slice must already include a slot at index zero for the hidden

/// return parameter; that slot is filled by this function.

fn emitCallValue(

    self: *mut FnLowerer,

    callee: il::Val,

    fnInfo: *resolver::FnType,

    args: *mut [il::Val],

) -> il::Val throws (LowerError) {

    let retTy = *fnInfo.returnType;

    if requiresReturnParam(fnInfo) {

        if fnInfo.throwList.len > 0 {

            let layout = resolver::getResultLayout(retTy, fnInfo.throwList);

            func: callee,

        func: callee,

            let slot = emitReserveLayout(self, resolver::Layout {

                size: resolver::PTR_SIZE,

                alignment: resolver::PTR_SIZE,

            });

/// Lower a method receiver expression to a pointer value.

///

/// If the parent is already a pointer type, the value is used directly.

/// If the parent is a value type (eg. a local record), its address is taken.

fn lowerReceiver(self: *mut FnLowerer, parent: *ast::Node, parentTy: resolver::Type) -> il::Val

    throws (LowerError)

{

    if let case resolver::Type::Pointer { .. } = parentTy {

        // Already a pointer: lower and use directly.

        return try lowerExpr(self, parent);

    }

    // Value type: take its address by lowering it and returning the slot pointer.

    // Aggregate types are already lowered as pointers to stack slots.

    let val = try lowerExpr(self, parent);

    if isAggregateType(parentTy) {

        return val;

    }

    // Scalar value: store to a stack slot and return the slot pointer.

    let layout = resolver::getLayout(self.low.resolver, parent, parentTy);

    let slot = emitReserveLayout(self, layout);

    try emitStore(self, slot, 0, parentTy, val);

    return il::Val::Reg(slot);

}

/// Lower a standalone method call via direct dispatch.

///

/// Given `obj.method(args)` where `method` is a standalone method on a concrete type,

/// emits a direct call with the receiver address as the first argument:

///

///     call <retTy> %ret @Type::method(&obj, args...)

///

fn lowerMethodCall(

    self: *mut FnLowerer,

    node: *ast::Node,

    call: ast::Call,

    method: *resolver::MethodEntry,

) -> il::Val throws (LowerError) {

    let case ast::NodeValue::FieldAccess(access) = call.callee.value

        else throw LowerError::MissingMetadata;

    // Get the receiver as a pointer.

    let parentTy = resolver::typeFor(self.low.resolver, access.parent)

        else throw LowerError::MissingType(access.parent);

    let receiverVal = try lowerReceiver(self, access.parent, parentTy);

    let qualName = instanceMethodName(self.low, nil, method.concreteTypeName, method.name);

    let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnInfo), .. } = method.symbol.data

        else panic "lowerMethodCall: expected Fn type on method symbol";

    // Build args: optional return param slot + receiver + user args.

    let argOffset: u32 = 1 if requiresReturnParam(fnInfo) else 0;

    let args = try allocVals(self, call.args.len + 1 + argOffset);

    args[argOffset] = receiverVal;

    for arg, i in call.args {

        args[i + 1 + argOffset] = try lowerExpr(self, arg);

    }

    return try emitCallValue(self, il::Val::FnAddr(qualName), fnInfo, args);

}

    let offset: u32 = 1 if requiresReturnParam(fnInfo) else 0;

    return try emitCallValue(self, callee, fnInfo, args);

        case ast::NodeValue::MethodDecl { .. } => return false,

    // Method syntax: `fn (recv: *Type) name(params) { body }`.

    if check(p, scanner::TokenKind::LParen) {

        return try parseMethodDecl(p, attrs);

    }

        try expect(p, scanner::TokenKind::Fn, "expected `fn`");

        let method = try parseMethodDecl(p, nil);

/// Parse a method declaration with a receiver.

///

/// Used both inside `instance` blocks and as standalone methods at the top level.

/// Expects the `fn` token to have already been consumed.

fn parseMethodDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node

    return node(p, ast::NodeValue::MethodDecl {

        name, receiverName, receiverType, sig, body, attrs,

/// Maximum standalone methods (across all types).

pub const MAX_METHODS: u32 = 256;

/// An entry in the method registry.

pub record MethodEntry {

    /// Concrete type that owns the method.

    concreteType: Type,

    /// Name of the concrete type.

    concreteTypeName: *[u8],

    /// Method name.

    name: *[u8],

    /// Function type excluding the receiver.

    fnType: *FnType,

    /// Whether the receiver is mutable.

    mutable: bool,

    /// Symbol for the method.

    symbol: *mut Symbol,

}

    /// Standalone method call metadata.

    MethodCall { method: *MethodEntry },

    /// Standalone method registry.

    methods: [MethodEntry; MAX_METHODS],

    /// Number of registered standalone methods.

    methodsLen: u32,

        methods: undefined,

        methodsLen: 0,

        case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, attrs } => {

            try resolveMethodDecl(self, node, name, receiverName, receiverType, sig, attrs);

        }

        case ast::NodeValue::MethodDecl { receiverName, sig, body, .. } => {

            try resolveMethodBody(self, node, receiverName, sig, body);

        }

        let case ast::NodeValue::MethodDecl {

            name, receiverName, receiverType, sig, body, ..

        let case ast::NodeValue::MethodDecl {

            name, receiverName, receiverType, sig, body, ..

        try resolveMethodBody(self, methodNode, receiverName, sig, body);

    }

}

/// Resolve a method body shared by instance methods and standalone methods.

/// Binds the receiver and parameters, then type-checks the body.

fn resolveMethodBody(

    self: *mut Resolver,

    node: *ast::Node,

    receiverName: *ast::Node,

    sig: ast::FnSig,

    body: *ast::Node,

) throws (ResolveError) {

    let sym = symbolFor(self, node)

        else throw emitError(self, node, ErrorKind::Internal);

    let case SymbolData::Value { type: Type::Fn(fnType), .. } = sym.data

        else panic "resolveMethodBody: expected value symbol";

    // Enter function scope.

    enterFn(self, node, fnType);

    // Bind the receiver parameter.

    let receiverTy = *fnType.paramTypes[0];

    try bindValueIdent(self, receiverName, receiverName, receiverTy, false, 0, 0) catch {

        exitFn(self);

        throw ResolveError::Failure;

    };

    // Bind the remaining parameters from the signature.

    for paramNode in sig.params {

        let paramTy = try infer(self, paramNode) catch {

    }

    // Resolve the body.

    let retTy = *fnType.returnType;

    let bodyTy = try checkAssignable(self, body, Type::Void) catch {

        exitFn(self);

        throw ResolveError::Failure;

    };

    if retTy != Type::Void and bodyTy != Type::Never {

        throw emitError(self, body, ErrorKind::FnMissingReturn);

    exitFn(self);

}

/// Resolve a standalone method declaration (signature only).

/// Validates the receiver type and registers the method in the method table.

/// Extract the type name from a resolved receiver type node (`*T` or `*mut T`).

fn receiverTypeName(self: *mut Resolver, receiverType: *ast::Node) -> *[u8] throws (ResolveError) {

    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer { valueType, .. }) = receiverType.value

        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);

    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(nameNode)) = valueType.value

        else throw emitError(self, receiverType, ErrorKind::Internal);

    let sym = symbolFor(self, nameNode)

        else throw emitError(self, receiverType, ErrorKind::Internal);

    return sym.name;

}

fn resolveMethodDecl(

    self: *mut Resolver,

    node: *ast::Node,

    name: *ast::Node,

    receiverName: *ast::Node,

    receiverType: *ast::Node,

    sig: ast::FnSig,

    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

        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);

    // Get the type name from the inner type node's symbol.

    let typeName = try receiverTypeName(self, receiverType);

    let methodName = try nodeName(self, name);

    // Reject duplicate method for the same (type, name).

    if let _ = findMethod(self, concreteType, methodName) {

        throw emitError(self, name, ErrorKind::DuplicateBinding(methodName));

    }

    // Resolve parameter types.

    let a = alloc::arenaAllocator(&mut self.arena);

    let mut paramTypes: *mut [*Type] = &mut [];

    // Receiver is the first parameter.

    let receiverPtrType = Type::Pointer {

        target: allocType(self, concreteType),

        mutable: receiverMut,

    };

    paramTypes.append(allocType(self, receiverPtrType), a);

    for paramNode in sig.params {

        let case ast::NodeValue::FnParam(param) = paramNode.value

            else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);

        let paramTy = try resolveValueType(self, param.type);

        paramTypes.append(allocType(self, paramTy), a);

    }

    // Resolve return type.

    let mut returnType = Type::Void;

    if let retNode = sig.returnType {

        returnType = try resolveValueType(self, retNode);

    }

    // Resolve throw list.

    let mut throwTypes: *mut [*Type] = &mut [];

    for throwNode in sig.throwList {

        let throwTy = try resolveValueType(self, throwNode);

        throwTypes.append(allocType(self, throwTy), a);

    }

    let retTypePtr = allocType(self, returnType);

    let throwList = &throwTypes[..];

    // Full function type (receiver + params) for lowering.

    let fullFnType = FnType {

        paramTypes: &paramTypes[..], returnType: retTypePtr, throwList, localCount: 0,

    };

    let fnTy = Type::Fn(allocFnType(self, fullFnType));

    // Function type excluding receiver, for call arg checking.

    let checkFnType = FnType {

        paramTypes: &paramTypes[1..], returnType: retTypePtr, throwList, localCount: 0,

    };

    // Compute attribute mask.

    let mut attrMask: u32 = 0;

    if let a = attrs {

        for attrNode in a.list {

            if let case ast::NodeValue::Attribute(attr) = attrNode.value {

                attrMask = attrMask | (attr as u32);

            }

        }

    }

    // Create a symbol for the method without binding it into the module scope.

    let sym = allocSymbol(self, SymbolData::Value {

        mutable: false, alignment: 0, type: fnTy, addressTaken: false,

    }, methodName, node, attrMask);

    setNodeSymbol(self, node, sym);

    setNodeType(self, node, fnTy);

    setNodeType(self, name, fnTy);

    // Register in the method table.

    if self.methodsLen >= MAX_METHODS {

        throw emitError(self, node, ErrorKind::Internal);

    }

    self.methods[self.methodsLen] = MethodEntry {

        concreteType,

        concreteTypeName: typeName,

        name: methodName,

        fnType: allocFnType(self, checkFnType),

        mutable: receiverMut,

        symbol: sym,

    };

    self.methodsLen += 1;

/// Look up a standalone method by concrete type and name.

pub fn findMethod(self: *Resolver, concreteType: Type, name: *[u8]) -> ?*MethodEntry {

    for i in 0..self.methodsLen {

        let entry = &self.methods[i];

        if typesEqual(entry.concreteType, concreteType) and entry.name == name {

            return entry;

        }

    }

    return nil;

}

/// Look up a standalone method entry by its symbol.

pub fn findMethodBySymbol(self: *Resolver, sym: *mut Symbol) -> ?*MethodEntry {

    for i in 0..self.methodsLen {

        let entry = &self.methods[i];

        if entry.symbol == sym {

            return entry;

        }

    }

    return nil;

}

        // Check for a standalone method call on a concrete type.

        if let case Type::Nominal(_) = subjectTy {

            let methodName = try nodeName(self, access.child);

            if let method = findMethod(self, subjectTy, methodName) {

                // Reject mutable-receiver methods on immutable bindings.

                // If the parent is already a mutable pointer, the receiver is fine.

                // Otherwise, check that the parent can yield a mutable borrow.

                if method.mutable {

                    let mut isMutPtr = false;

                    if let case Type::Pointer { mutable, .. } = parentTy {

                        isMutPtr = mutable;

                    }

                    if not isMutPtr and not (try canBorrowMutFrom(self, access.parent)) {

                        throw emitError(self, access.parent, ErrorKind::ImmutableBinding);

                    }

                }

                // Check arguments (excluding receiver).

                try checkCallArgs(self, node, call, method.fnType, ctx);

                self.nodeData.entries[node.id].extra = NodeExtra::MethodCall { method };

                return setNodeType(self, node, *method.fnType.returnType);

            }

        }

            if let fieldIndex = findRecordField(&recordType, fieldName) {

                let fieldTy = recordType.fields[fieldIndex].fieldType;

                setRecordFieldIndex(self, fieldNode, fieldIndex);

                return setNodeType(self, node, fieldTy);

            }

            // Not a field: check for a standalone method.

            if let method = findMethod(self, subjectTy, fieldName) {

                return setNodeType(self, node, Type::Fn(method.fnType));

            }

            throw emitError(self, node, ErrorKind::RecordFieldUnknown(fieldName));

        else => {

            // Check for standalone methods on any nominal type (e.g. unions).

            if let case Type::Nominal(_) = subjectTy {

                let fieldName = try nodeName(self, access.child);

                if let method = findMethod(self, subjectTy, fieldName) {

                    return setNodeType(self, node, Type::Fn(method.fnType));

                }

            }

        }

//! returns: 0

//! Basic standalone method test.

record Point {

    x: i32,

    y: i32,

}

fn (p: *Point) sum() -> i32 {

    return p.x + p.y;

}

fn (p: *mut Point) translate(dx: i32, dy: i32) {

    p.x = p.x + dx;

    p.y = p.y + dy;

}

@default fn main() -> i32 {

    let mut pt = Point { x: 3, y: 4 };

    // Call immutable method.

    assert pt.sum() == 7;

    // Call mutable method.

    pt.translate(10, 20);

    assert pt.x == 13;

    assert pt.y == 24;

    // Call via pointer.

    let ptr = &pt;

    assert ptr.sum() == 37;

    return 0;

}

//! returns: 0

//! Method chaining via mutable pointer returns.

record Builder {

    x: i32,

    y: i32,

}

fn (b: *mut Builder) setX(x: i32) -> *mut Builder {

    b.x = x;

    return b;

}

fn (b: *mut Builder) setY(y: i32) -> *mut Builder {

    b.y = y;

    return b;

}

fn (b: *Builder) sum() -> i32 {

    return b.x + b.y;

}

@default fn main() -> i32 {

    let mut b = Builder { x: 0, y: 0 };

    // Chain method calls.

    let p = b.setX(10).setY(20);

    assert p.sum() == 30;

    // Original also modified.

    assert b.sum() == 30;

    return 0;

}

//! returns: 0

//! Multiple methods on the same type.

record Vec2 {

    x: i32,

    y: i32,

}

fn (v: *Vec2) magnitudeSq() -> i32 {

    return v.x * v.x + v.y * v.y;

}

fn (v: *Vec2) dot(other: *Vec2) -> i32 {

    return v.x * other.x + v.y * other.y;

}

fn (v: *mut Vec2) add(other: *Vec2) {

    v.x = v.x + other.x;

    v.y = v.y + other.y;

}

fn (v: *mut Vec2) scale(factor: i32) {

    v.x = v.x * factor;

    v.y = v.y * factor;

}

@default fn main() -> i32 {

    let mut a = Vec2 { x: 3, y: 4 };

    let b = Vec2 { x: 1, y: 2 };

    // Immutable method.

    assert a.magnitudeSq() == 25;

    // Method with pointer parameter.

    assert a.dot(&b) == 11;

    // Mutable method with pointer parameter.

    a.add(&b);

    assert a.x == 4;

    assert a.y == 6;

    // Mutable method with scalar parameter.

    a.scale(2);

    assert a.x == 8;

    assert a.y == 12;

    return 0;

}

//! returns: 0

//! Methods called via various pointer indirections.

record Counter {

    value: i32,

}

fn (c: *Counter) get() -> i32 {

    return c.value;

}

fn (c: *mut Counter) inc() {

    c.value = c.value + 1;

}

@default fn main() -> i32 {

    let mut c = Counter { value: 0 };

    // Direct call on value.

    assert c.get() == 0;

    // Mutable method on value.

    c.inc();

    assert c.get() == 1;

    // Call via immutable pointer.

    let p = &c;

    assert p.get() == 1;

    // Call via mutable pointer.

    let mp = &mut c;

    mp.inc();

    assert mp.get() == 2;

    // Original value also updated.

    assert c.get() == 2;

    return 0;

}

//! returns: 0

//! Public attribute on standalone methods.

record Foo {

    x: i32,

}

pub fn (f: *Foo) getX() -> i32 {

    return f.x;

}

@default fn main() -> i32 {

    let f = Foo { x: 42 };

    assert f.getX() == 42;

    return 0;

}

//! returns: 0

//! Methods returning various types and records.

record Pair {

    a: i32,

    b: i32,

}

fn (p: *Pair) sum() -> i32 {

    return p.a + p.b;

}

fn (p: *Pair) swapped() -> Pair {

    return Pair { a: p.b, b: p.a };

}

fn (p: *Pair) firstPtr() -> *i32 {

    return &p.a;

}

@default fn main() -> i32 {

    let pair = Pair { a: 10, b: 20 };

    // Scalar return.

    assert pair.sum() == 30;

    // Aggregate return.

    let s = pair.swapped();

    assert s.a == 20;

    assert s.b == 10;

    // Pointer return.

    let ptr = pair.firstPtr();

    assert *ptr == 10;

    return 0;

}

//! returns: 0

//! Methods that throw errors.

union ParseError {

    Invalid,

}

record Parser {

    pos: i32,

    len: i32,

}

fn (p: *mut Parser) advance() throws (ParseError) {

    if p.pos >= p.len {

        throw ParseError::Invalid;

    }

    p.pos = p.pos + 1;

}

fn (p: *Parser) remaining() -> i32 {

    return p.len - p.pos;

}

@default fn main() -> i32 {

    let mut parser = Parser { pos: 0, len: 2 };

    // Advance successfully.

    try parser.advance() catch {

        assert false;

    };

    assert parser.remaining() == 1;

    // Advance again.

    try parser.advance() catch {

        assert false;

    };

    assert parser.remaining() == 0;

    // Advance past end -- should throw.

    let mut threw = false;

    try parser.advance() catch {

        threw = true;

    };

    assert threw;

    return 0;

}

//! returns: 0

//! Standalone methods on union types.

union Shape {

    Circle(i32),

    Rect { w: i32, h: i32 },

}

fn (s: *Shape) isCircle() -> bool {

    match *s {

        case Shape::Circle(_) => return true,

        else => return false,

    }

}

@default fn main() -> i32 {

    let c = Shape::Circle(5);

    let r = Shape::Rect { w: 3, h: 4 };

    assert c.isCircle();

    assert not r.isCircle();

    return 0;

}

//! returns: 0

//! Standalone methods coexisting with trait instances on the same type.

record Widget {

    x: i32,

    y: i32,

}

// Standalone method.

fn (w: *Widget) area() -> i32 {

    return w.x * w.y;

}

// Trait with its own method.

trait Printable {

    fn (*Printable) code() -> i32;

}

instance Printable for Widget {

    fn (w: *Widget) code() -> i32 {

        return w.x + w.y;

    }

}

@default fn main() -> i32 {

    let w = Widget { x: 3, y: 5 };

    // Standalone method call.