options: LowerOptions,

}

/// Entry mapping a function or data symbol to its emitted name.

record SymbolNameEntry: Copy {

    /// Qualified name in the emitted program.

    qualName: *[u8],

}

/// Entry in the global error tag table.

// Qualified Name Construction //

/////////////////////////////////

/// Get module path segments for the current or specified module.

/// Returns empty slice if no module graph or module not found.

    let graph = self.moduleGraph else {

        return &[];

    };

    let mut id = modId;

    if id == nil {

}

/// Register the emitted name for a function or data symbol.

/// Calls and address expressions use this name across package boundaries.

unsafe fn registerSymbolName 'arena 'phase (self: &mut Lowerer 'arena 'phase, sym: *unsafe resolver::Symbol, qualName: *[u8]) where 'arena: 'phase {

}

/// Look up the emitted name for a function or data symbol.

/// Return `nil` if its declaration has not been lowered.

// TODO: This is kind of dubious as an optimization, if it depends on the order

// in which modules are lowered.

// TODO: Use a hash table here?

    for entry in &self.symbolNames[..] {

            return entry.qualName;

        }

    }

    return nil;

}

    };

    if data.ty == resolver::Type::Unknown {

        throw LowerError::MissingType(node);

    }

    let layout = resolver::getTypeLayout(data.ty);

    let mut b = dataBuilder(alloc::arenaAllocator(self.arena));

    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);

    let result = dataBuilderFinish(b);

    self.data.append(il::Data {

/// Emit a copy instruction that loads a data symbol's address into a register.

unsafe fn emitDataAddr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, sym: *unsafe resolver::Symbol) -> il::Reg where 'arena: 'phase, 'phase: 'function {

    let dst = nextReg(self);

    let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);

    emit(self, il::Instr::Copy { dst, val: il::Val::DataSym(qualName) });

    return dst;

}

    if let sym = resolver::nodeData(self.low.resolver, callee).sym {

        if let case ast::NodeValue::FnDecl(_) = sym.node.value {

            // First try to look up the symbol in our registered functions.

            // This handles cross-package calls correctly, since packages are

            // lowered in dependency order.

                return il::Val::FnAddr(qualName);

            }

            // Fall back to computing the qualified name from the module graph.

            // This works for functions in the current package.

            let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);

    Trait(*unsafe mut TraitType),

}

/// Resolved symbol allocated during semantic analysis.

export record Symbol: Copy {

    /// Symbol name in source code.

    name: *[u8],

    /// Data associated with the symbol.

    data: SymbolData,

    /// Bitset of attributes applied to the declaration.

    Place,

    /// Evaluate a place prefix after checking the complete place.

    Locate,

}

/// Per-control-flow-path ownership state.

/// Read only the initialized symbol prefix below `len`.

record LinearEnv: Copy {

    /// Active full-region loans, indexed by the checker's regional loan table.

    regionalLoans: u64,

    /// Bit set for each binding that remains available.

    available: u64,

    /// Number of initialized entries in `symbols`.

    len: u32,

    /// Whether this control-flow path has terminated.

    next: ?*unsafe NominalApplication,

}

/// Global resolver state.

export record Resolver: 'arena {

    /// Active region names for source type checking.

    regionScope: ?*RegionScope,

    /// Interned applications of nominal region parameters.

    applications: ?*unsafe NominalApplication,

    /// Current scope.

    // TODO: Simplify.

    for i in 0..moduleScopes.len {

        set moduleScopes[i] = nil;

    }

    return Resolver 'arena {

        regionScope: nil,

        applications: nil,

        scope: pkgScope,

        pkgScope: pkgScope,

        loopStack: undefined,

}

/// Allocate a new symbol, and return a reference to it.

unsafe fn allocSymbol 'arena (self: &mut Resolver 'arena, data: SymbolData, name: *[u8], node: *ast::Node, attrs: u32) -> *unsafe mut Symbol {

    let sym = try! alloc::allocRaw(self.arena, @sizeOf(Symbol), @alignOf(Symbol)) as *unsafe mut Symbol;

    return sym;

}

/// Check that a type is boolean, otherwise throw an error.

        try visitDecl(res, stmt);

    }

}

/// Find a tracked binding by symbol identity.

    for i in 0..env.len {

            return i;

        }

    }

    return nil;

}

        return;

    }

    if env.len >= MAX_LINEAR_BINDINGS {

        throw emitError(checker.resolver, node, ErrorKind::Internal);

    }

    set env.available |= (1 as u64) << (env.len as u64);

    set env.len += 1;

}

/// Mark a tracked binding as uninitialized.

unsafe fn markLinearBindingUnavailable 'arena (self: &mut Resolver 'arena, env: &mut LinearEnv, node: *ast::Node) {

    let sym = symbolFor(self, node) else return;

    set env.available &= ~((1 as u64) << (index as u64));

}

/// Require exact-use bindings introduced after `start` to be consumed.

unsafe fn finishLinearScope 'arena 'checking (

    start: u32,

) throws (ResolveError) where 'arena: 'checking {

    if not env.terminated {

        for i in start..env.len {

            if linearBindingAvailable(env, i) {

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

                    else panic "finishLinearScope: expected value symbol";

                if isLinear(ty) {

                    throw emitError(

                        checker.resolver,

    checker: &mut LinearChecker 'arena 'checking,

    env: &mut LinearEnv,

    node: *ast::Node,

) throws (ResolveError) where 'arena: 'checking {

    let sym = symbolFor(checker.resolver, node) else return;

    if not linearBindingAvailable(env, index) {

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

            else panic "consumeLinearIdent: expected value symbol";

        let kind = ErrorKind::LinearUseAfterConsume(sym.name) if isLinear(ty)

            else ErrorKind::AffineUseAfterMove(sym.name);

    env: &mut LinearEnv,

    node: *ast::Node,

) throws (ResolveError) where 'arena: 'checking {

    try checkLinearIdent(checker, env, node);

    let sym = symbolFor(checker.resolver, node) else return;

    set env.available &= ~((1 as u64) << (index as u64));

}

/// Merge ownership availability across two live branches.

/// Validate both inputs before writing to an output that can alias either input.

    }

    assert left.len == right.len, "joinLinearBranches: scope mismatch";

    let mut available = left.available;

    for i in 0..left.len {

        if linearBindingAvailable(left, i) <> linearBindingAvailable(right, i) {

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

                else panic "joinLinearBranches: expected value symbol";

            if isLinear(ty) {

                throw emitError(

                    checker.resolver,

    if env.terminated {

        return;

    }

    for i in 0..env.len {

        if linearBindingAvailable(env, i) {

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

                else panic "finishLinearExit: expected value symbol";

            if isLinear(ty) {

                throw emitError(

                    checker.resolver,

    let mark = checker.loopMarks[depth];

    let entryAvailable = checker.loopAvailable[depth];

    for i in 0..mark {

        let bit = (1 as u64) << (i as u64);

        if (env.available & bit) <> (entryAvailable & bit) {

            throw emitError(

                checker.resolver,

                node,

                ErrorKind::LinearBranchMismatch(sym.name),

            );

    if checker.loopHasNaturalExit[depth] or checker.loopBreakSeen[depth] {

        let expected = checker.loopExitAvailable[depth];

        for i in 0..mark {

            let bit = (1 as u64) << (i as u64);

            if (env.available & bit) <> (expected & bit) {

                throw emitError(

                    checker.resolver,

                    node,

                    ErrorKind::LinearBranchMismatch(sym.name),

                );

            }

            case ast::ProngArm::Else => {}

        }

        if prong.guard <> nil {

            for i in bindingsStart..branch.len {

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

                    else panic "checkLinearMatch: expected value symbol";

                if isLinear(ty) {

                    throw emitError(checker.resolver, prongNode, ErrorKind::LinearDiscard);

                }

            if let leftTy = typeFor(checker.resolver, assign.left) {

                if isMoveOnly(leftTy) {

                    set targetLinear = isLinear(leftTy);

                    if let case ast::NodeValue::Ident(_) = assign.left.value {

                        if let sym = symbolFor(checker.resolver, assign.left) {

                        }

                    }

                    if targetLinear and target == nil {

                        throw emitError(

                            checker.resolver,

use std::mem;

use std::testing;

use std::lang::types;

use std::lang::resolver;

/// Short-circuit paths must agree on exact-use regional ownership.

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

    for program in [

        "union Ticket: 'r + Once { Value(&'r u32) } fn take 'r (t: Ticket 'r) -> bool { match t { case Ticket::Value(p) => return *p == 1, } } fn f 'r (t: Ticket 'r) { let result = false and take(t); }",