///

/// Called after each function.

///

/// Uses two-instruction sequences: short branches use `branch` and `nop`,

/// long branches use inverted branch  and `jal` or `auipc` and `jalr`.

    for i in 0..e.pendingBranches.len {

        let p = e.pendingBranches[i];

        let offset = labels::branchToBlock(&e.labels, p.index, p.target, super::INSTR_SIZE);

        match p.kind {

            case BranchKind::Cond { op, rs1, rs2 } => {

/// Allocate a slice of `count` elements, each of `size` bytes with given alignment.

///

/// Returns a type-erased slice that should be cast to the appropriate `*[T]`.

/// The slice length is set to `count` (element count, not bytes).

/// Throws `AllocError` if the arena is exhausted.

    if count == 0 {

        return &mut [];

    }

    let ptr = try alloc(arena, size * count, alignment);

    return sym;

}

/// Remove the last block parameter and its associated variable.

/// Used when detecting a trivial phi that can be eliminated.

    let blk = getBlockMut(self, block);

    if blk.params.len > 0 {

        // TODO: Use `pop`?

        set blk.params = @sliceOf(blk.params.ptr, blk.params.len - 1, blk.params.cap);

    }

fn enterVarScope(self: &FnLowerer) -> u32 {

    return self.vars.len;

}

/// Restore lexical variable scope depth.

    set self.vars = @sliceOf(self.vars.ptr, savedVarsLen, self.vars.cap);

}

/// Get the metadata for a variable.

fn getVar(self: &FnLowerer, v: Var) -> *VarData {

    }

    return &errs[index];

}

/// Record an error diagnostic and return an error sentinel suitable for throwing.

    // If our error list is full, just return an error without recording it.

    if self.errors.len >= self.errors.cap {

        return ResolveError::Failure;

    }

    // Don't record more than one error per node.

    return ResolveError::Failure;

}

/// Like [`emitError`], but for type mismatches specifically.

    return emitError(self, node, ErrorKind::TypeMismatch(mismatch));

}

/// Allocate a scope object with the given symbol capacity.

unsafe fn allocScope(self: &mut Resolver, owner: *ast::Node, capacity: u32) -> *mut Scope {

    }

    return Type::Never;

}

/// Require that loop control statements appear inside a loop.

    if self.loopDepth == 0 {

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

    }

}

    set self.currentFn = nil;

    exitScope(self);

}

/// Extract the identifier text from a node.

    throws (ResolveError)

{

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

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

    return name;

    return sym;

}

/// Add a symbol to the given scope.

    for i in 0..scope.symbolsLen {

        if scope.symbols[i].name == sym.name {

            throw emitError(self, site, ErrorKind::DuplicateBinding(sym.name));

        }

    }

}

/// Flatten an identifier or scope access chain into an array of name segments.

/// Examples: `fnord` -> `&["fnord"]`, `a::b::c` -> `&["a", "b", "c"]`.

/// Return the number of segments written to the buffer.

    self: &mut Resolver,

    node: *ast::Node,

    buf: &mut [*[u8]]

) -> u32 throws (ResolveError) {

    let mut out: u32 = 0;

    return try resolveModulePathRecursive(self, module, &pathBuf[1..pathLen], sym);

}

/// Recursively resolve the remaining path segments by traversing child modules.

    self: &mut Resolver,

    node: *ast::Node,

    path: &[*[u8]],

    sym: *Symbol

) -> ResolvedModule throws (ResolveError) {

        }

    }

}

/// Require the current function to be unsafe.

    if not self.inUnsafeFn {

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

    }

}

/// Reject calls from safe code through unsafe function types.

    throws (ResolveError)

{

    if info.isUnsafe and not self.inUnsafeFn {

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

    }

unsafe fn infer(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {

    return try visit(self, node, Type::Unknown);

}

/// Reject nested references while allowing a direct parameter reference.

    throws (ResolveError)

{

    if isRefType(ty) {

        if let case Type::Pointer { target, .. } = ty {

            if containsRef(*target) {

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

    }

}

/// Require a type that may be stored or escape a call.

    throws (ResolveError)

{

    if containsRef(ty) {

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

    }

    }

    return mask;

}

/// Ensure the `default` attribute is only applied to functions.

    throws (ResolveError)

{

    let defaultBit = ast::Attribute::Default as u32;

    if (attrs & defaultBit) <> 0 {

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

        try checkAssignable(self, arg, fieldType);

    }

}

/// Check that the argument count of a constructor pattern or call matches the record field count.

    if args.len <> recInfo.fields.len {

        throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(CountMismatch {

            expected: recInfo.fields.len as u32,

            actual: args.len,

        }));

/// 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.

    self: &mut Resolver,

    receiverType: *ast::Node,

) -> *[u8] throws (ResolveError) {

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

        receiverType.value

        };

        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 { class, item: target, mutable });

    }

    if args.len <> 1 {

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

            expected: 1,

        try checkIndex(self, end);

    }

}

/// Emit an error when a slice range with compile-tyime values exceeds the array length.

    let mut startVal: ?u32 = nil;

    let mut endVal: ?u32 = length;

    if let startNode = range.start {

        if let val = constSliceIndex(self, startNode) {

    });

    return setNodeType(self, node, arrayTy);

}

/// Resolve union variant access.

    self: &mut Resolver,

    node: *ast::Node,

    access: ast::Access,

    unionType: UnionType,

    variantName: *[u8]

    }

    return types::PointerClass::Ref;

}

/// Select an address type without extending the target storage lifetime.

    throws (ResolveError)

{

    if isUnsafePointerType(hint) {

        try requireUnsafe(self, target);

        return types::PointerClass::Unsafe;

/// Test @sliceOf with correct arguments succeeds.

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

    // Immutable pointer.

    {

        let mut a = testResolver();

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

        try expectNoErrors(&result);

    }

    // Mutable pointer produces mutable slice.

    {

        let mut a = testResolver();

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

        try expectNoErrors(&result);

    }

}

/// Test @sliceOf with 3 arguments (ptr, len, cap) succeeds.

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

    {

        let mut a = testResolver();

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

        try expectNoErrors(&result);

    }

    // Mutable pointer produces mutable slice.

    {

        let mut a = testResolver();

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

        try expectNoErrors(&result);

    }

}

    try expectAnalyzeOk("fn run(value: *u32) -> *u32 { return &*value; }");

    try expectAnalyzeOk("fn run(values: *[u32]) -> *[u32] { return &values[..]; }");

    try expectAnalyzeOk("record Cell { value: u32 } fn run(value: *Cell) -> *u32 { return &value.value; }");

    try expectAnalyzeOk("fn run(values: *[u32]) -> *u32 { return &values[0]; }");

    try expectAnalyzeOk("fn run(values: *[u32]) -> *u32 { return values.ptr; }");

}

/// References are rejected from every nested or storable type position.

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

    {

    try expectAnalyzeOk("fn run(p: *u8) -> *opaque { return p as *opaque; }");

    try expectAnalyzeOk("fn run(s: *[u8]) -> *[opaque] { return s as *[opaque]; }");

    try expectAnalyzeOk("fn run(p: *mut u8) -> *u8 { return p as *u8; }");

}

/// Unsafe declarations may compose unsafe operations and calls.

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

    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";

    try expectAnalyzeOk(program);

}

    let c: *[i32] = s;

    return c;

}

/// Builds a slice header from a pointer and length.

    return @sliceOf(ptr, len);

}

/// Builds a slice header from pointer, length, and capacity.

    return @sliceOf(ptr, len, cap);

}

//! returns: 0

//! Test that @sliceOf produces a fat pointer with the correct length.

    return @sliceOf(ptr, count);

}

@default unsafe fn main() -> i32 {

    let mut arr: [i32; 4] = [10, 20, 30, 40];