};

        let qualName = instanceMethodName(self, nil, typeName, mName);

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

            else continue;

            else panic "lowerInstanceDecl: method not found in trait";

        set state.methodNames[method.index] = qualName;

        set state.methodNameSet[method.index] = true;

        return func;

    setNodeType(self, name, Type::Void);

    return sym;

}

        }

    }

    return nil;

}

                actual: traitType.methods.len as u32 + superTrait.methods.len as u32,

            }));

        }

        // Copy inherited methods into this trait's method table.

        for inherited in superTrait.methods {

                throw emitError(self, superNode, ErrorKind::DuplicateBinding(inherited.name));

            }

            traitType.methods.append(TraitMethod {

                name: inherited.name,

                fnType: inherited.fnType,

        let attrMask = resolveAttributes(attrs);

        let previousRegions = self.regionScope;

        set self.regionScope = try bindRegions(self, methodNode, modifiers.regions);

        // Reject duplicate method names.

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

        }

        // Determine the receiver class and mutability, and validate that it

        // points to the declaring trait.

        let case ast::NodeValue::TypeSig(typeSig) = receiver.value

}

/// Resolved implementation of one trait method.

record ResolvedInstanceMethod: Copy {

    /// Canonical trait method.

    /// Concrete function symbol.

    symbol: *unsafe mut Symbol,

}

/// Shared declaration state for instance method resolution.

    let methodScope = try bindRegions(self, methodNode, combinedRegions);

    set self.regionScope = methodScope;

    let methodName = try nodeName(self, name);

    let attrMask = resolveAttributes(modifiers.attrs);

        else throw emitError(self, name, ErrorKind::UnresolvedSymbol(methodName));

    if ast::hasAttribute(attrMask, ast::Attribute::Unsafe) <> tm.fnType.isUnsafe {

        throw emitError(self, methodNode, ErrorKind::TraitMethodSafetyMismatch);

    }

    // Fill inherited method slots from supertrait instances.

    for superTrait in traitInfo.supertraits {

        let superInst = findInstance(self, superTrait, concreteType)

            else throw emitError(self, node, ErrorKind::MissingSupertraitInstance(superTrait.name));

        for superMethod, mi in superTrait.methods {

                else panic "resolveInstanceDecl: inherited method not found";

            if not covered[merged.index] {

                set entry.methods[merged.index] = superInst.methods[mi];

                set covered[merged.index] = true;

            }

}

/// Validate the reservation ABI used by typed session allocation.

unsafe fn sessionRuntime 'arena (

    self: &mut Resolver 'arena, node: *ast::Node, slice: bool

    throws (ResolveError)

{

    let allocTrait = allocationSymbol(self, "Alloc")

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

    let case SymbolData::Trait(allocInfo) = allocTrait.data

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

    let name = "reserveSlice" if slice else "reserve";

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

    let error = allocationSymbol(self, "AllocError")

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

    let case SymbolData::Type(errorType) = error.data

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

        }

        let subjectTy = autoDeref(parentTy);

        if let case Type::TraitObject { traitInfo, mutable: objMutable, .. } = subjectTy {

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

                else throw emitError(self, access.child, ErrorKind::RecordFieldUnknown(methodName));

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

            if method.mutable {

                if not objMutable or not try canMutateThrough(self, access.parent) {

        }

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

    }

    if let case Type::TraitObject { traitInfo, .. } = subjectTy {

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

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

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

    }

    match subjectTy {

        assert firstBinding.id == first.id;

        assert secondBinding.id == second.id;

    }

}

/// Iteration over raw slices requires permission to read their storage.

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

    for program in [

        "fn f(p: *unsafe [u32]) { for item in p { assert item == 0; } }",

        "fn f(p: *unsafe mut [u32]) { for item, index in p { assert item == index; } }",