return MatchSubject { effectiveTy: *target, by };

    }

    return MatchSubject { effectiveTy: ty, by: MatchBy::Value };

}

/// Region names introduced by a declaration or lexical block.

export record RegionScope: Copy {

    /// Entries in declaration order.

    entries: *unsafe [*unsafe mut types::Region],

    /// Enclosing lexical region environment.

    parent: ?*RegionScope,

}

        set *region = types::Region { id: node.id, origin: types::RegionOrigin::Parameter, name, parent: nil };

        set entries[index] = region;

        set index += 1;

    }

    let scope = try! alloc::alloc(&mut *self.arena, @sizeOf(RegionScope), @alignOf(RegionScope)) as *mut RegionScope;

    let frozen: *RegionScope = scope;

    set index = 0;

    for node in nodes {

        let case ast::NodeValue::Region { parent, .. } = node.value else continue;

        if let parentNode = parent {

    scope: ?*RegionScope, dependency: *unsafe types::Region, destination: ?*unsafe types::Region

) -> bool {

    if let region = destination {

        return types::regionContains(dependency, region);

    }

}

/// Require stored references to cover the lifetime of checked destination storage.

unsafe fn validateRegionalStore 'arena (self: &mut Resolver 'arena, place: *ast::Node, value: *ast::Node, ty: Type)

    throws (ResolveError)

    let entries = try! alloc::allocRawSlice(

        self.arena, @sizeOf(*unsafe mut types::Region), @alignOf(*unsafe mut types::Region), 1

    ) as *unsafe mut [*unsafe mut types::Region];

    set entries[0] = region;

    let scope = try! alloc::alloc(&mut *self.arena, @sizeOf(RegionScope), @alignOf(RegionScope)) as *mut RegionScope;

    return scope;

}

/// Qualify an existing-place borrow with its block's region.

unsafe fn qualifyBlockBorrow 'arena (

/// A projection loan that remains active until its named region ends.

record RegionalLoan: Copy {

    /// Address expression that supplies access to the loan.

    source: *ast::Node,

    /// Storage protected by the projection.

    place: BorrowPlace,

    /// Whether accesses through other references are excluded.

    exclusive: bool,

}

/// Return whether a region identity is visible in a lexical environment.

    let mut cursor = scope;

    while let current = cursor {

            }

        }

        set cursor = current.parent;

    }

    return false;

}

/// Retain only loans whose regions remain active at a control-flow destination.

    let mut result: u64 = 0;

    for i in 0..checker.regionalLen {

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

            set result |= bit;

        }

    }

    return result;

}

    }

    return result;

}

/// Reclaim ended-region entries and preserve loans for enclosing regions.

    checker: &mut LinearChecker 'arena 'checking, env: &mut LinearEnv,

    scope: ?*RegionScope

) where 'arena: 'checking {

    let oldLen = checker.regionalLen;

    let mut mapping: [u64; MAX_REGIONAL_LOANS] = [0; MAX_REGIONAL_LOANS];

    let mut next: u32 = 0;

    for i in 0..oldLen {

        let loan = checker.regional[i];

            set checker.regional[next] = loan;

            set mapping[i] = (1 as u64) << (next as u64);

            set next += 1;

        }

    }

    }

    if checker.regionalLen >= MAX_REGIONAL_LOANS {

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

    }

    let index = checker.regionalLen;

    set checker.regionalLen += 1;

    set env.regionalLoans |= (1 as u64) << (index as u64);

}

/// Return whether an initializer copies a shared reference with a named region.

        }

    }

}

/// Record the ownership state of a loop's condition-false exit.

    assert checker.loopDepth > 0, "linear loop exit outside loop";

    let depth = checker.loopDepth - 1;

    set checker.loopExitLoans[depth] |= regionalLoansInScope(checker, env.regionalLoans, checker.loopRegions[depth]);

    set checker.loopExitAvailable[depth] = env.available;

    set checker.loopHasNaturalExit[depth] = true;