use std::lang::alloc;

/// Maximum number of trait methods.

pub const MAX_TRAIT_METHODS: u32 = 8;

/// Arena for all parser allocations.

///

/// Uses a bump allocator for both AST nodes and node pointer arrays.

pub record NodeArena {

    /// Bump allocator for all allocations.

        }

        case super::NodeValue::UnionDeclVariant(v) => {

            return variantToExpr(a, v.name, v.type);

        }

        case super::NodeValue::ExprStmt(e) => return toExpr(a, e),

            let children = nodeListToExprs(a, &methods);

        }

        case super::NodeValue::TraitMethodSig { name, receiver, sig } => {

            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 tName = traitSym.name;

    let typeName = typeSym.name;

    // Lower each instance method as a regular function.

    let mut methodNames: [*[u8]; ast::MAX_TRAIT_METHODS] = undefined;

    for i in 0..methods.len {

        let methodNode = methods.list[i];

        let case ast::NodeValue::InstanceMethodDecl {

            name, receiverName, receiverType, sig, body

        let method = resolver::findTraitMethod(traitInfo, mName)

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

        methodNames[method.index] = qualName;

    }

    // Create v-table in data section, used for dynamic dispatch.

    let vName = vtableName(self, nil, typeName, tName);

    let values = try! alloc::allocSlice(

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

    throws (ParseError)

{

    try expect(p, scanner::TokenKind::Trait, "expected `trait`");

    let name = try parseIdent(p, "expected trait name");

    try expect(p, scanner::TokenKind::LBrace, "expected `{` after trait name");

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

    while not check(p, scanner::TokenKind::RBrace) and

          not check(p, scanner::TokenKind::Eof)

        let method = try parseTraitMethodSig(p);

        ast::nodeListPush(&mut methods, method);

    }

    try expect(p, scanner::TokenKind::RBrace, "expected `}` after trait methods");

}

/// Parse a trait method signature.

/// Syntax: `fn (*Trait) fnord(<params>) -> ReturnType;`

fn parseTraitMethodSig(p: *mut Parser) -> *ast::Node

    name: *[u8],

    /// Method signatures.

    methods: [TraitMethod; ast::MAX_TRAIT_METHODS],

    /// Number of methods.

    methodsLen: u32,

}

/// A single method signature within a trait.

pub record TraitMethod {

    /// Method name.

    FnParamOverflow(CountMismatch),

    /// Function declaration has too many throws.

    FnThrowOverflow(CountMismatch),

    /// Trait declaration has too many methods.

    TraitMethodOverflow(CountMismatch),

    /// Internal error.

    Internal,

}

/// Fixed-capacity diagnostic sink.

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

fn allocTraitType(self: *mut Resolver, name: *[u8]) -> *mut TraitType {

    let p = try! alloc::alloc(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));

    let entry = p as *mut TraitType;

    return entry;

}

/// Bind a trait name in the current scope.

        }

    }

    return nil;

}

    throws (ResolveError)

{

    let sym = symbolFor(self, node)

        else return;

    let case SymbolData::Trait(traitType) = sym.data

        entry.methodsLen += 1;

        covered[tm.index] = true;

    }

    // Check that all trait methods are implemented.

    for i in 0..traitInfo.methodsLen {

        if not covered[i] {

            throw emitError(self, node, ErrorKind::MissingTraitMethod(traitInfo.methods[i].name));

        }

            case ast::NodeValue::UnionDecl(decl) => {

                try resolveUnionBody(self, node, decl) catch {

                    // Continue resolving other types even if one fails.

                };

            }

                    // Continue resolving other types even if one fails.

                };

            }

            else => {

                // Ignore other declarations.

            io::print("too many trait methods: maximum ");

            io::printU32(mismatch.expected);

            io::print(", got ");

            io::printU32(mismatch.actual);

        }

        case super::ErrorKind::Internal => {

            io::print("internal compiler error");

        }

        case super::ErrorKind::RecordFieldOutOfOrder { .. } => {

            io::print("record field out of order");