/// A single method signature within a trait.

export record TraitMethod: Copy {

    /// Method name.

    name: *[u8],

    /// Function type for the method, excluding the receiver.

    /// Whether the receiver is mutable.

    mutable: bool,

    /// Pointer-like class used by the receiver.

    receiverClass: types::PointerClass,

    /// V-table slot index.

    /// Name of the concrete type.

    concreteTypeName: *[u8],

    /// Method name.

    name: *[u8],

    /// Function type excluding the receiver.

    /// Whether the receiver is mutable.

    mutable: bool,

    /// Pointer-like class used by the receiver.

    receiverClass: types::PointerClass,

    /// Symbol for the method.

    /// Eg. `[i32; 32]`.

    Array(ArrayType),

    /// Eg. `?T`.

    Optional(*Type),

    /// Eg. `fn id(i32) -> i32`.

    /// Named, ie. user-defined types, includes union variants.

    Nominal(*NominalType),

    /// Owning trait object. An erased type with v-table.

    TraitObject {

        /// Ownership and safety class.

    /// Stack of loop contexts for nested loops.

    loopStack: [LoopCtx; MAX_LOOP_DEPTH],

    /// Current loop depth, indexes into loop stack.

    loopDepth: u32,

    /// Signature of the function currently being analyzed.

    /// Current module being analyzed.

    currentMod: u16,

    /// Whether the current lexical context permits unsafe operations.

    inUnsafeContext: bool,

    /// Configuration for semantic analysis.

    return entry;

}

/// Allocate a function type descriptor and return a pointer to it.

    let entry = try! alloc::alloc(

        &mut self.arena, @sizeOf(FnType), @alignOf(FnType)

    ) as *mut FnType;

    set *entry = info;

        }

    }

}

/// Set the expected return type for a new function body.

    assert self.currentFn == nil, "enterFn: already in a function";

    enterScope(self, node);

}

/// Clear the expected return type when leaving a function body.

fn exitFn(self: &mut Resolver) {

        throwList: &[],

        isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),

        localCount: 0,

    };

    // Enter the function scope to process parameters.

    if decl.sig.params.len > MAX_FN_PARAMS {

        exitFn(self);

        throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {

            expected: MAX_FN_PARAMS,

/// Resolve a function or method body and restore the enclosing context.

unsafe fn resolveExecutableBody(

    self: &mut Resolver,

    node: *ast::Node,

    receiverName: ?*ast::Node,

    params: *mut [*ast::Node],

    body: *ast::Node,

) throws (ResolveError) {

    let wasUnsafe = self.inUnsafeContext;

            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 {

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

                    }

                }

                // Check arguments (excluding receiver).

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

    // Slice assignment: `slice[range] = value`.

    if let case ast::NodeValue::Subscript { container, index } = assign.left.value {

        if let case ast::NodeValue::Range(range) = index.value {

            try infer(self, index);

            let containerTy = try infer(self, container);

                throw emitError(self, container, ErrorKind::ImmutableBinding);

            }

            let subjectTy = autoDeref(containerTy);

            try checkSliceRangeIndices(self, range);

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

        }

    }

}

/// Determine whether an expression can yield a mutable location for borrowing.

unsafe fn canBorrowMutFrom(self: &mut Resolver, node: *ast::Node) -> bool

    throws (ResolveError)

{

    match node.value {

        case ast::NodeValue::Ident(name) => {

            let sym = findValueSymbol(self.scope, name)

                else return false;

            let case SymbolData::Value { mutable, .. } = sym.data

                else return false;

        }

        case ast::NodeValue::FieldAccess(access) => {

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

            if let case Type::Slice { .. } = autoDeref(parentTy) {

                try requireUnsafe(self, node);

            }

        }

        case ast::NodeValue::ScopeAccess(_) => {

            // Module-qualified access to a top-level symbol. A `static`

            // binds as a mutable value; a `constant` does not.

            let _ = try infer(self, node);

            if let case Type::Slice { mutable, .. } = subjectTy {

                return mutable;

            }

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

            }

            return false;

        }

        case ast::NodeValue::ArrayLit(_),

             ast::NodeValue::ArrayRepeatLit(_) =>

@test unsafe fn testPointerArithmeticRequiresUnsafe() throws (testing::TestError) {

    let programs = &[

        "fn run(p: *u8) -> *u8 { return p + 1; }",

        "fn run(p: *u8) -> *u8 { return 1 + p; }",

        "fn run(p: *u8) -> *u8 { return p - 1; }",

        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let p = &DATA[0]; return *(p + 1); }",

    ];

    for program in programs {

        let mut a = testResolver();

        let result = try resolveProgramStr(&mut a, program);

        let mut a = testResolver();

        let result = try resolveProgramStr(&mut a, program);

        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));

    }

}