SYMBOL INDEX (1838 symbols across 123 files)

FILE: cli/src/bin/ivy.rs
  function main (line 4) | fn main() -> Result<()> {

FILE: cli/src/bin/vine.rs
  function main (line 4) | fn main() -> Result<()> {

FILE: cli/src/common.rs
  type Optimizations (line 20) | pub struct Optimizations {
    method apply (line 26) | pub fn apply(&self, nets: &mut Nets, entrypoints: &[String]) {
  type RunArgs (line 34) | pub struct RunArgs {
    method output (line 50) | pub fn output(&self, nets: &Nets) -> (RunResult, Vec<u8>) {
    method check (line 72) | pub fn check(&self, nets: &Nets, debug_hint: bool) {
    method run (line 76) | pub fn run<R: Read, W: Write>(
  type RunResult (line 121) | pub struct RunResult {
    method check (line 129) | pub fn check(&self, debug_hint: bool) {
    method success (line 158) | pub fn success(&self) -> bool {
  function parse_size (line 163) | fn parse_size(size: &str) -> anyhow::Result<usize> {

FILE: cli/src/ivy_cli.rs
  type IvyCommand (line 15) | pub enum IvyCommand {
    method execute (line 26) | pub fn execute() -> Result<()> {
  type IvyRunCommand (line 37) | pub struct IvyRunCommand {
    method execute (line 45) | pub fn execute(self) -> Result<()> {
  type IvyOptimizeCommand (line 54) | pub struct IvyOptimizeCommand {
    method execute (line 64) | pub fn execute(&self) -> Result<()> {
  type IvyReplCommand (line 70) | pub struct IvyReplCommand {
    method execute (line 78) | pub fn execute(self) -> Result<()> {
  type IvyCompletionCommand (line 110) | pub struct IvyCompletionCommand {
    method execute (line 115) | pub fn execute(self) -> Result<()> {

FILE: cli/src/vine_cli.rs
  type VineCommand (line 37) | pub enum VineCommand {
    method execute (line 58) | pub fn execute() -> Result<()> {
  type LibArgs (line 74) | pub struct LibArgs {
    method initialize (line 82) | fn initialize(mut self, compiler: &mut Compiler) -> IdxVec<FileId, Pat...
  type CheckArgs (line 99) | pub struct CheckArgs {
  type CompileArgs (line 106) | pub struct CompileArgs {
    method initialize (line 117) | fn initialize(self) -> Compiler {
    method compile (line 127) | fn compile(self) -> (Nets, Compiler) {
  function root_source (line 140) | fn root_source() -> Source {
  type VineRunCommand (line 161) | pub struct VineRunCommand {
    method execute (line 171) | pub fn execute(self) -> Result<()> {
  type VineTestCommand (line 181) | pub struct VineTestCommand {
    method execute (line 200) | pub fn execute(mut self) -> Result<()> {
    method matching_tests (line 238) | fn matching_tests(tests: &[String], compiler: &Compiler) -> Vec<(Strin...
  type VineBuildCommand (line 254) | pub struct VineBuildCommand {
    method execute (line 264) | pub fn execute(self) -> Result<()> {
  type VineCheckCommand (line 277) | pub struct VineCheckCommand {
    method execute (line 287) | pub fn execute(self) -> Result<()> {
  type VineReplCommand (line 358) | pub struct VineReplCommand {
    method execute (line 371) | pub fn execute(self) -> Result<()> {
  type VineFmtCommand (line 415) | pub struct VineFmtCommand {
    method execute (line 420) | pub fn execute(self) -> Result<()> {
    method fmt (line 446) | fn fmt(path: impl fmt::Display, src: &str) -> Option<String> {
  type VineLspCommand (line 458) | pub struct VineLspCommand {
    method execute (line 464) | pub fn execute(self) -> Result<()> {
  type VineCompletionCommand (line 473) | pub struct VineCompletionCommand {
    method execute (line 478) | pub fn execute(self) -> Result<()> {
  type VineDocCommand (line 490) | pub struct VineDocCommand {
    method execute (line 497) | pub fn execute(self) -> Result<()> {
  function eprint_diags (line 511) | fn eprint_diags(compiler: &Compiler) {
  function print_diags (line 515) | fn print_diags(compiler: &Compiler) {
  function _print_diags (line 519) | fn _print_diags(mut w: impl io::Write + IsTerminal, compiler: &Compiler)...
  type Colors (line 558) | struct Colors {
  function colors (line 568) | fn colors(t: &impl IsTerminal) -> Colors {
  type Source (line 585) | struct Source {
  type Parser (line 591) | type Parser = ParseSource;
  method value_parser (line 592) | fn value_parser() -> Self::Parser {
  type ParseSource (line 598) | struct ParseSource;
  type Value (line 601) | type Value = Source;
  method parse_ref (line 603) | fn parse_ref(
  function build_config (line 641) | fn build_config(args: Vec<String>) -> HashMap<String, String> {

FILE: ivm/src/addr.rs
  type Addr (line 14) | pub struct Addr(pub *const ());
    constant NULL (line 20) | pub const NULL: Addr = Addr(ptr::null());
    method as_word (line 27) | pub(crate) unsafe fn as_word<'ivm>(self) -> &'ivm AtomicWord {
    method as_global (line 36) | pub unsafe fn as_global<'ivm>(self) -> &'ivm Global<'ivm> {
    constant HALF_BIT (line 40) | const HALF_BIT: u64 = 0b1000;
    method map_addr (line 43) | fn map_addr(self, f: impl FnOnce(u64) -> u64) -> Self {
    method other_half (line 49) | pub fn other_half(self) -> Self {
    method left_half (line 55) | pub fn left_half(self) -> Self {
  method fmt (line 61) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: ivm/src/allocator.rs
  type Allocator (line 10) | pub(crate) struct Allocator<'ivm> {
  function new (line 20) | pub(crate) fn new(heap: &'ivm Heap) -> Self {
  function shrink (line 24) | pub(crate) fn shrink(&mut self) {
  function fork (line 29) | pub(crate) fn fork(&mut self, index: usize, count: usize) -> Self {
  function new_node (line 46) | pub unsafe fn new_node(&mut self, tag: Tag, label: u16) -> (Port<'ivm>, ...
  function new_wire (line 54) | pub fn new_wire(&mut self) -> (Wire<'ivm>, Wire<'ivm>) {
  function new_wires (line 63) | pub fn new_wires(&mut self) -> ((Wire<'ivm>, Wire<'ivm>), (Wire<'ivm>, W...
  function free_wire (line 75) | pub(crate) fn free_wire(&mut self, wire: Wire<'ivm>) {
  function alloc_node (line 92) | fn alloc_node(&mut self) -> Addr {

FILE: ivm/src/ext.rs
  type Extrinsics (line 34) | pub struct Extrinsics<'ivm> {
  method default (line 48) | fn default() -> Self {
  constant MAX_EXT_FN_COUNT (line 62) | pub const MAX_EXT_FN_COUNT: usize = 0x3FFF;
  constant MAX_EXT_TY_COUNT (line 63) | pub const MAX_EXT_TY_COUNT: usize = 0x7FFF;
  function new_split_ext_fn (line 65) | pub fn new_split_ext_fn(&mut self, f: impl ExtSplitFn<'ivm>) -> ExtFn<'i...
  function new_merge_ext_fn (line 74) | pub fn new_merge_ext_fn(&mut self, f: impl ExtMergeFn<'ivm>) -> ExtFn<'i...
  function new_ext_ty (line 83) | pub fn new_ext_ty<T: ExtTyCast<'ivm>>(&mut self) -> ExtTy<'ivm, T> {
  function n32_ext_ty (line 90) | pub fn n32_ext_ty(&self) -> ExtTy<'ivm, u32> {
  function ext_val_as_n32 (line 94) | pub fn ext_val_as_n32(&self, x: ExtVal<'ivm>) -> Option<u32> {
  function get_ext_split_fn (line 98) | pub fn get_ext_split_fn(&self, ext_fn: ExtFn<'ivm>) -> &dyn ExtSplitFn<'...
  function get_ext_merge_fn (line 102) | pub fn get_ext_merge_fn(&self, ext_fn: ExtFn<'ivm>) -> &dyn ExtMergeFn<'...
  type ExtVal (line 116) | pub struct ExtVal<'ivm>(Word, PhantomData<fn(&'ivm ()) -> &'ivm ()>);
  constant PAYLOAD_MASK (line 119) | const PAYLOAD_MASK: u64 = 0x0000_FFFF_FFFF_FFF8;
  function from_bits (line 126) | pub unsafe fn from_bits(bits: Word) -> Self {
  function bits (line 132) | pub fn bits(&self) -> Word {
  function new (line 142) | pub fn new(ty_id: ExtTyId<'ivm>, payload: Word) -> Self {
  function ty_id (line 157) | pub fn ty_id(&self) -> ExtTyId<'ivm> {
  function payload (line 166) | fn payload(&self) -> Word {
  function cast (line 176) | pub unsafe fn cast<T: ExtTyCast<'ivm>>(self) -> T {
  method fmt (line 182) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ExtTy (line 187) | pub struct ExtTy<'ivm, T>(ExtTyId<'ivm>, PhantomData<fn(T) -> T>);
  method clone (line 190) | fn clone(&self) -> Self {
  function new_unchecked (line 198) | pub fn new_unchecked(ty_id: ExtTyId<'ivm>) -> Self {
  function ty_id (line 203) | pub fn ty_id(self) -> ExtTyId<'ivm> {
  function unwrap_ext_val (line 212) | pub fn unwrap_ext_val(self, ext: ExtVal<'ivm>) -> Option<T>
  function wrap_ext_val (line 221) | pub fn wrap_ext_val(self, value: T) -> ExtVal<'ivm>
  type ExtTyCast (line 233) | pub trait ExtTyCast<'ivm> {
    constant COPY (line 234) | const COPY: bool;
    method into_payload (line 240) | fn into_payload(self) -> Word;
    method from_payload (line 247) | unsafe fn from_payload(payload: Word) -> Self;
  constant COPY (line 251) | const COPY: bool = true;
  function into_payload (line 254) | fn into_payload(self) -> Word {
  function from_payload (line 259) | unsafe fn from_payload(payload: Word) -> u32 {
  constant COPY (line 265) | const COPY: bool = true;
  function into_payload (line 268) | fn into_payload(self) -> Word {
  function from_payload (line 273) | unsafe fn from_payload(payload: Word) -> f32 {
  constant COPY (line 280) | const COPY: bool = false;
  function into_payload (line 283) | fn into_payload(self) -> Word {
  function from_payload (line 288) | unsafe fn from_payload(_payload: Word) {}
  type Aligned (line 293) | pub struct Aligned<T>(T);
  type Boxed (line 297) | pub struct Boxed<T>(Box<Aligned<T>>);
  function from (line 300) | fn from(value: T) -> Self {
  type Target (line 306) | type Target = T;
  method deref (line 308) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 314) | fn deref_mut(&mut self) -> &mut Self::Target {
  function ptr (line 320) | fn ptr(self) -> *mut Aligned<T> {
  function into_inner (line 324) | pub fn into_inner(self) -> T {
  function into_aligned_ptr (line 328) | fn into_aligned_ptr(value: T) -> *mut Aligned<T> {
  function from_aligned_ptr (line 332) | unsafe fn from_aligned_ptr(ptr: *mut Aligned<T>) -> Self {
  constant COPY (line 338) | const COPY: bool = false;
  function into_payload (line 341) | fn into_payload(self) -> Word {
  function from_payload (line 346) | unsafe fn from_payload(payload: Word) -> Self {
  constant COPY (line 352) | const COPY: bool = false;
  function into_payload (line 355) | fn into_payload(self) -> Word {
  function from_payload (line 360) | unsafe fn from_payload(payload: Word) -> Self {
  type ExtTyId (line 371) | pub struct ExtTyId<'ivm>(u16, PhantomData<&'ivm mut &'ivm ()>);
  constant COPY_BIT (line 374) | const COPY_BIT: u16 = 0x8000;
  function new (line 377) | fn new(ty_id: u16, copy: bool) -> Self {
  function from_bits (line 382) | fn from_bits(bits: u16) -> Self {
  function bits (line 387) | fn bits(self) -> u16 {
  function is_copy (line 392) | pub fn is_copy(self) -> bool {
  type ExtFn (line 404) | pub struct ExtFn<'ivm>(u16, PhantomData<fn(&'ivm ()) -> &'ivm ()>);
  constant SWAP_BIT (line 407) | const SWAP_BIT: u16 = 0x8000;
  constant MERGE_BIT (line 408) | const MERGE_BIT: u16 = 0x4000;
  constant ID_MASK (line 409) | const ID_MASK: u16 = 0x3FFF;
  function new_split (line 412) | fn new_split(id: usize) -> Self {
  function new_merge (line 417) | fn new_merge(id: usize) -> Self {
  function index (line 422) | fn index(&self) -> usize {
  function bits (line 427) | pub fn bits(&self) -> u16 {
  function is_swapped (line 432) | pub fn is_swapped(&self) -> bool {
  function is_merge (line 437) | pub fn is_merge(&self) -> bool {
  function swapped (line 442) | pub fn swapped(&self) -> Self {
  method fmt (line 448) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type OpaqueExtFn (line 454) | pub struct OpaqueExtFn {

FILE: ivm/src/flags.rs
  type Flags (line 3) | pub struct Flags {
    method success (line 13) | pub fn success(self) -> bool {

FILE: ivm/src/global.rs
  type Global (line 5) | pub struct Global<'ivm> {
  type LabelSet (line 22) | pub struct LabelSet {
    constant NONE (line 32) | pub const NONE: Self = Self { cap: 0, bits: Vec::new() };
    method add (line 36) | pub fn add(&mut self, label: u16) {
    method has (line 51) | pub fn has(&self, label: u16) -> bool {
    method union (line 62) | pub fn union(&mut self, other: &LabelSet) {

FILE: ivm/src/heap.rs
  type Heap (line 8) | pub struct Heap(pub(crate) [Node]);
    method new (line 25) | pub fn new() -> Box<Self> {
    method with_size (line 39) | pub fn with_size(bytes: usize) -> Option<Box<Self>> {
    method slice (line 53) | pub(crate) fn slice(&self, range: impl SliceIndex<[Node], Output = [No...
  type Node (line 12) | pub(crate) struct Node(pub AtomicWord, pub AtomicWord);
  constant HEAP_SIZE_BYTES (line 15) | pub const HEAP_SIZE_BYTES: usize = if cfg!(miri) {

FILE: ivm/src/instruction.rs
  type Instructions (line 11) | pub struct Instructions<'ivm> {
  method default (line 21) | fn default() -> Self {
  function new_register (line 29) | pub fn new_register(&mut self) -> Register {
  function push (line 41) | pub unsafe fn push(&mut self, instruction: Instruction<'ivm>) {
  function instructions (line 46) | pub fn instructions(&self) -> &[Instruction<'ivm>] {
  type Instruction (line 57) | pub enum Instruction<'ivm> {
  type Register (line 79) | pub struct Register {
    constant ROOT (line 92) | pub const ROOT: Register = Register::new(0);
    method new (line 96) | const fn new(index: usize) -> Self {
    method index (line 102) | pub fn index(&self) -> usize {
  constant REGISTER_SIZE (line 88) | const REGISTER_SIZE: u32 = 8;
  method fmt (line 108) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function link_register (line 119) | unsafe fn link_register(&mut self, register: Register, port: Port<'ivm>) {
  function execute (line 133) | pub fn execute(&mut self, instructions: &Instructions<'ivm>, port: Port<...

FILE: ivm/src/interact.rs
  function link (line 18) | pub fn link(&mut self, a: Port<'ivm>, b: Port<'ivm>) {
  function link_wire (line 39) | pub fn link_wire(&mut self, a: Wire<'ivm>, b: Port<'ivm>) {
  function link_wire_wire (line 53) | pub fn link_wire_wire(&mut self, a: Wire<'ivm>, b: Wire<'ivm>) {
  function follow (line 59) | pub fn follow(&mut self, mut p: Port<'ivm>) -> Port<'ivm> {
  function follow_ref (line 74) | pub fn follow_ref<'a>(&self, p: &'a Port<'ivm>) -> PortRef<'a, 'ivm> {
  function interact (line 87) | pub(crate) fn interact(&mut self, a: Port<'ivm>, b: Port<'ivm>) {
  function expand (line 120) | fn expand(&mut self, c: Port<'ivm>, p: Port<'ivm>) {
  function annihilate (line 126) | fn annihilate(&mut self, a: Port<'ivm>, b: Port<'ivm>) {
  function copy (line 134) | fn copy(&mut self, n: Port<'ivm>, b: Port<'ivm>) {
  function commute (line 141) | fn commute(&mut self, a: Port<'ivm>, b: Port<'ivm>) {
  function call (line 162) | fn call(&mut self, f: Port<'ivm>, lhs: Port<'ivm>) {
  function branch (line 195) | fn branch(&mut self, b: Port<'ivm>, v: Port<'ivm>) {

FILE: ivm/src/ivm.rs
  type IVM (line 14) | pub struct IVM<'ivm, 'ext> {
  function new (line 42) | pub fn new(heap: &'ivm Heap, extrinsics: &'ext Extrinsics<'ivm>) -> Self {
  function new_from_allocator (line 46) | pub(crate) fn new_from_allocator(
  function normalize (line 65) | pub fn normalize(&mut self) {
  function do_fast (line 78) | pub(crate) fn do_fast(&mut self) {
  function normalize_breadth_first (line 88) | pub fn normalize_breadth_first(&mut self) {

FILE: ivm/src/parallel.rs
  function normalize_parallel (line 11) | pub fn normalize_parallel(&mut self, threads: usize) {
  type Msg (line 50) | struct Msg<'ivm> {
  type Shared (line 57) | struct Shared<'ivm, 'ext> {
  type Pairs (line 63) | type Pairs<'ivm> = Vec<(Port<'ivm>, Port<'ivm>)>;
  type MsgKind (line 66) | enum MsgKind {
  type Worker (line 75) | struct Worker<'w, 'ivm, 'ext> {
  constant ERA_LENGTH (line 81) | const ERA_LENGTH: u32 = 512;
  function execute (line 84) | fn execute(mut self) {
  function work (line 89) | fn work(&mut self) {
  type WorkerHandle (line 145) | struct WorkerHandle<'w, 'ivm, 'ext> {
  type Dispatch (line 149) | struct Dispatch<'w, 'ivm, 'ext> {
  function execute (line 155) | fn execute(mut self) {

FILE: ivm/src/port.rs
  type Port (line 30) | pub struct Port<'ivm>(NonZeroWord, PhantomData<fn(&'ivm ()) -> &'ivm ()>);
  type Tag (line 38) | pub enum Tag {
  constant ERASE (line 75) | pub const ERASE: Self = unsafe { Port::from_bits(Word::from_bits(Tag::Er...
  function from_bits (line 82) | pub(crate) const unsafe fn from_bits(word: Word) -> Self {
  function bits (line 86) | pub(crate) fn bits(&self) -> Word {
  function option_from_bits (line 96) | pub(crate) unsafe fn option_from_bits(word: Word) -> Option<Self> {
  function new (line 105) | pub unsafe fn new(tag: Tag, label: u16, addr: Addr) -> Self {
  function tag (line 117) | pub fn tag(&self) -> Tag {
  function label (line 124) | pub fn label(&self) -> u16 {
  function addr (line 131) | pub fn addr(&self) -> Addr {
  function new_global (line 137) | pub fn new_global(global: &'ivm Global) -> Self {
  function new_wire (line 143) | pub fn new_wire(wire: Wire<'ivm>) -> Self {
  function new_ext_val (line 149) | pub fn new_ext_val(val: ExtVal) -> Self {
  function clone (line 161) | pub unsafe fn clone(&self) -> Self {
  function as_ext_fn (line 170) | pub unsafe fn as_ext_fn(&self) -> ExtFn<'ivm> {
  function as_wire (line 182) | pub unsafe fn as_wire(self) -> Wire<'ivm> {
  function as_ext_val (line 194) | pub unsafe fn as_ext_val(&self) -> ExtVal<'ivm> {
  function as_global (line 204) | pub unsafe fn as_global(&self) -> &'ivm Global<'ivm> {
  function aux (line 217) | pub unsafe fn aux(self) -> (Wire<'ivm>, Wire<'ivm>) {
  function aux_ref (line 227) | pub unsafe fn aux_ref(&self) -> (WireRef<'_, 'ivm>, WireRef<'_, 'ivm>) {
  method fmt (line 238) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PortRef (line 252) | pub struct PortRef<'a, 'ivm>(Port<'ivm>, PhantomData<&'a ()>);
  function from_port (line 255) | pub(crate) fn from_port(port: Port<'ivm>) -> Self {
  function new_wire (line 260) | pub fn new_wire(wire: &Wire<'ivm>) -> Self {
  type Target (line 266) | type Target = Port<'ivm>;
  method deref (line 268) | fn deref(&self) -> &Self::Target {
  function from (line 274) | fn from(port: &'a Port<'ivm>) -> Self {

FILE: ivm/src/stats.rs
  type Stats (line 10) | pub struct Stats {
    method interactions (line 44) | pub fn interactions(&self) -> u64 {
    method speed (line 49) | pub fn speed(&self) -> u64 {
    method clock_speed (line 54) | pub fn clock_speed(&self) -> u64 {
    method worker_avg (line 59) | pub fn worker_avg(&self) -> u64 {
    method breadth (line 64) | pub fn breadth(&self) -> u64 {
    method speedup (line 68) | pub fn speedup(&self) -> u64 {
    method clear_perf (line 72) | pub fn clear_perf(&mut self) {
    method add_assign (line 188) | fn add_assign(&mut self, rhs: Stats) {
  method fmt (line 82) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function measure_int (line 178) | const fn measure_int(int: u64) -> usize {

FILE: ivm/src/wire.rs
  type Wire (line 21) | pub struct Wire<'ivm>(Addr, PhantomData<&'ivm mut &'ivm ()>);
  function from_addr (line 27) | pub unsafe fn from_addr(addr: Addr) -> Self {
  function target (line 31) | fn target(&self) -> &'ivm AtomicWord {
  function load_target (line 36) | pub(crate) fn load_target(&self) -> Option<Port<'ivm>> {
  function swap_target (line 41) | pub(crate) fn swap_target(&self, new: Option<Port<'ivm>>) -> Option<Port...
  function addr (line 47) | pub(crate) fn addr(&self) -> Addr {
  function clone (line 59) | pub unsafe fn clone(&self) -> Self {
  method fmt (line 65) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type WireRef (line 71) | pub struct WireRef<'a, 'ivm>(Wire<'ivm>, PhantomData<&'a ()>);
  function from_wire (line 74) | pub(crate) fn from_wire(wire: Wire<'ivm>) -> Self {
  type Target (line 80) | type Target = Wire<'ivm>;
  method deref (line 82) | fn deref(&self) -> &Self::Target {
  function from (line 88) | fn from(wire: &'a Wire<'ivm>) -> Self {

FILE: ivm/src/word.rs
  type Word (line 22) | pub struct Word(#[cfg(not(miri))] u64, #[cfg(miri)] *mut ());
    method from_bits (line 28) | pub const fn from_bits(bits: u64) -> Self {
    method from_bits (line 35) | pub const fn from_bits(bits: u64) -> Self {
    method from_ptr (line 41) | pub fn from_ptr(ptr: *const ()) -> Self {
    method bits (line 48) | pub fn bits(self) -> u64 {
    method bits (line 55) | pub fn bits(self) -> u64 {
    method ptr (line 61) | pub fn ptr(self) -> *const () {
    method map_bits (line 68) | pub fn map_bits(self, f: impl FnOnce(u64) -> u64) -> Self {
    method map_bits (line 75) | pub fn map_bits(self, f: impl FnOnce(u64) -> u64) -> Self {
  type AtomicWord (line 82) | pub(crate) struct AtomicWord(#[cfg(not(miri))] AtomicU64, #[cfg(miri)] A...
    method load (line 86) | pub fn load(&self) -> Word {
    method store (line 91) | pub fn store(&self, word: Word) {
    method swap (line 96) | pub fn swap(&self, word: Word) -> Word {
    method compare_exchange (line 101) | pub fn compare_exchange(&self, current: Word, new: Word) -> Result<Wor...
  type NonZeroWord (line 109) | pub(crate) struct NonZeroWord(#[cfg(not(miri))] NonZeroU64, #[cfg(miri)]...
    method new_unchecked (line 114) | pub const unsafe fn new_unchecked(word: Word) -> Self {
    method new_unchecked (line 120) | pub const unsafe fn new_unchecked(word: Word) -> Self {
    method get (line 126) | pub fn get(&self) -> Word {
    method get (line 132) | pub fn get(&self) -> Word {

FILE: ivy/src/ast.rs
  type Tree (line 12) | pub enum Tree {
    method n_ary (line 107) | pub fn n_ary(
    method children (line 118) | pub fn children(&self) -> impl DoubleEndedIterator + ExactSizeIterator...
    method children_mut (line 130) | pub fn children_mut(&mut self) -> impl DoubleEndedIterator + ExactSize...
  type Net (line 27) | pub struct Net {
    method new (line 33) | pub fn new(root: Tree) -> Self {
    method trees (line 98) | pub fn trees(&self) -> impl DoubleEndedIterator<Item = &Tree> + Clone {
    method trees_mut (line 101) | pub fn trees_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Tr...
  type Nets (line 39) | pub struct Nets(IndexMap<String, Net>);
  type Target (line 42) | type Target = IndexMap<String, Net>;
  method deref (line 43) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 49) | fn deref_mut(&mut self) -> &mut Self::Target {
  method fmt (line 55) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 74) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 89) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: ivy/src/host.rs
  type Host (line 18) | pub struct Host<'ivm> {
  function get (line 42) | pub fn get(&self, name: &str) -> Option<&'ivm Global<'ivm>> {
  function get_raw (line 46) | fn get_raw(&self, name: &str) -> Option<*const Global<'ivm>> {
  function label_to_u16 (line 50) | pub fn label_to_u16<'l>(
  function label_from_u16 (line 64) | pub fn label_from_u16(label: u16, labels: &IndexMap<String, ()>) -> &str {
  function ext_ty (line 68) | fn ext_ty<T>(&self, name: &'static str) -> ExtTy<'ivm, T> {
  function new_f32 (line 72) | pub fn new_f32(&self, payload: f32) -> ExtVal<'ivm> {
  function new_f64 (line 76) | pub fn new_f64(&self, payload: f64) -> ExtVal<'ivm> {
  function new_n32 (line 80) | pub fn new_n32(&self, payload: u32) -> ExtVal<'ivm> {
  function new_io (line 84) | pub fn new_io(&self) -> ExtVal<'ivm> {
  function instantiate_ext_fn (line 88) | pub fn instantiate_ext_fn(&self, ext_fn_name: &str, swap: bool) -> Optio...

FILE: ivy/src/host/ext.rs
  function register_ext_fn (line 128) | pub fn register_ext_fn(&mut self, name: impl Into<String>, f: ExtFn<'ivm...
  function register_ext_ty_id (line 134) | pub fn register_ext_ty_id(&mut self, name: String, ty_id: ExtTyId<'ivm>) {
  function register_n32_ext_ty (line 139) | fn register_n32_ext_ty(&mut self, extrinsics: &mut Extrinsics<'ivm>) -> ...
  function register_ext_ty (line 145) | fn register_ext_ty<T: ExtTyCast<'ivm>>(
  function register_default_extrinsics (line 155) | pub fn register_default_extrinsics(&mut self, extrinsics: &mut Extrinsic...
  function register_runtime_extrinsics (line 247) | pub fn register_runtime_extrinsics<R: Read, W: Write>(
  function read_char (line 433) | fn read_char<R: Read>(mut reader: R) -> Result<(usize, Option<char>), io...
  function read_bytes_into_char (line 453) | fn read_bytes_into_char<R: Read>(
  function ext_val_as_str (line 471) | fn ext_val_as_str<'ivm>(n32: ExtTy<'ivm, u32>, chars: Vec<ExtVal<'ivm>>)...

FILE: ivy/src/host/readback.rs
  function read (line 13) | pub fn read<'ext>(&self, ivm: &IVM<'ivm, 'ext>, port: &Port<'ivm>) -> Tr...
  function reader (line 17) | pub fn reader<'ctx, 'ext>(&'ctx self, ivm: &'ctx IVM<'ivm, 'ext>) -> Rea...
  type Reader (line 22) | pub struct Reader<'ctx, 'ivm, 'ext> {
  function new (line 30) | fn new(ivm: &'ctx IVM<'ivm, 'ext>, host: &'ctx Host<'ivm>) -> Self {
  function read_port (line 34) | pub fn read_port(&mut self, p: &Port<'ivm>) -> Tree {
  function read_wire (line 92) | fn read_wire(&mut self, w: &Wire<'ivm>) -> Box<Tree> {

FILE: ivy/src/host/serialize.rs
  function insert_nets (line 67) | pub fn insert_nets(self: &mut &'ivm mut Host<'ivm>, nets: &Nets) {
  function _insert_nets (line 71) | pub(crate) fn _insert_nets(self: &mut &'ivm mut Host<'ivm>, nets: &Nets,...
  type Serializer (line 118) | struct Serializer<'host, 'ast, 'ivm> {
  function push (line 130) | fn push(&mut self, instruction: Instruction<'ivm>) {
  function serialize_net (line 134) | fn serialize_net(&mut self, net: &'ast Net) {
  function serialize_pair (line 169) | fn serialize_pair(&mut self, a: &'ast Tree, b: &'ast Tree) {
  function serialize_tree (line 181) | fn serialize_tree(&mut self, tree: &'ast Tree) -> Register {
  function serialize_tree_to (line 192) | fn serialize_tree_to(&mut self, tree: &'ast Tree, to: Register) {
  function unbox (line 268) | fn unbox(&mut self, mut tree: &'ast Tree) -> &'ast Tree {
  type PropagateLabels (line 278) | struct PropagateLabels<'ivm> {
  type Node (line 283) | type Node = &'ivm UnsafeCell<Global<'ivm>>;
  method state (line 285) | fn state(&mut self, cur: Self::Node) -> &BicycleState {
  method visit (line 289) | fn visit(&mut self, cur: Self::Node, mut recurse: impl FnMut(&mut Self, ...

FILE: ivy/src/lexer.rs
  type Token (line 9) | pub enum Token {
  type Lexer (line 33) | pub struct Lexer<'src> {
  function new (line 38) | pub fn new(src: &'src str) -> Self {
  type Token (line 44) | type Token = Token;
  type Error (line 45) | type Error = ParseError<'src>;
  function state (line 47) | fn state(&self) -> &LexerState<'src> {
  function state_mut (line 51) | fn state_mut(&mut self) -> &mut LexerState<'src> {
  function lex (line 55) | fn lex(&mut self) -> Result<Self::Token, Self::Error> {
  method into_u8 (line 119) | fn into_u8(self) -> u8 {

FILE: ivy/src/optimize.rs
  type Optimizer (line 15) | pub struct Optimizer {
    method optimize (line 20) | pub fn optimize(&mut self, nets: &mut Nets, entrypoints: &[String]) {
    method _optimize (line 26) | fn _optimize(&mut self, nets: &mut Nets, entrypoints: &[String]) {

FILE: ivy/src/optimize/eta_reduce.rs
  method eta_reduce (line 11) | pub fn eta_reduce(&mut self) -> bool {
  type NodeKind (line 26) | enum NodeKind {
  type WalkTrees (line 37) | struct WalkTrees<'a> {
  function walk_tree (line 43) | fn walk_tree(&mut self, tree: &'a Tree) {
  type ReduceTrees (line 71) | struct ReduceTrees<'a> {
  function reduce_tree (line 78) | fn reduce_tree(&mut self, tree: &mut Tree) -> &'a NodeKind {

FILE: ivy/src/optimize/inline_globals.rs
  function inline_globals (line 6) | pub fn inline_globals(nets: &mut Nets) -> bool {
  type Inliner (line 18) | struct Inliner {
    method populate_candidates (line 24) | fn populate_candidates(&mut self, nets: &Nets) {
    method process (line 40) | fn process(&mut self, tree: &mut Tree) {
  method should_inline (line 55) | fn should_inline(&self) -> bool {
  method is_nilary (line 61) | fn is_nilary(&self) -> bool {

FILE: ivy/src/optimize/inline_vars.rs
  type InlineVars (line 9) | pub(super) struct InlineVars {
    method apply (line 16) | pub fn apply(&mut self, net: &mut Net) {
    method apply_tree (line 46) | fn apply_tree(&mut self, tree: &mut Tree) {

FILE: ivy/src/optimize/pre_reduce.rs
  function pre_reduce (line 13) | pub fn pre_reduce(nets: &mut Nets) {
  type PreReduce (line 56) | struct PreReduce<'a> {
  function visit_global (line 62) | fn visit_global(&mut self, name: &str) {
  function visit_net (line 78) | fn visit_net(&mut self, net: &Net) {
  function visit_tree (line 84) | fn visit_tree(&mut self, tree: &Tree) {

FILE: ivy/src/optimize/prune.rs
  function prune (line 6) | pub fn prune(nets: &mut Nets, entrypoints: &[String]) {
  type Prune (line 19) | struct Prune<'a> {
  function visit_global (line 25) | fn visit_global(&mut self, name: &str) {
  function visit_net (line 31) | fn visit_net(&mut self, net: &Net) {
  function visit_tree (line 37) | fn visit_tree(&mut self, tree: &Tree) {

FILE: ivy/src/parser.rs
  type Parser (line 11) | pub struct Parser<'src> {
  type ParseError (line 16) | pub enum ParseError<'src> {
  type Token (line 25) | type Token = Token;
  type Lexer (line 26) | type Lexer = Lexer<'src>;
  type Error (line 27) | type Error = ParseError<'src>;
  function state (line 29) | fn state(&mut self) -> &mut ParserState<'src, Lexer<'src>> {
  function unexpected_error (line 33) | fn unexpected_error(&self) -> ParseError<'src> {
  function new (line 42) | pub fn new(lexer: Lexer<'src>) -> Result<Self, ParseError<'src>> {
  function parse (line 46) | pub fn parse(src: &'src str) -> Result<Nets, ParseError<'src>> {
  function parse_n32 (line 57) | fn parse_n32(&mut self) -> Result<u32, ParseError<'src>> {
  function parse_f32 (line 62) | fn parse_f32(&mut self) -> Result<f32, ParseError<'src>> {
  function parse_f64 (line 67) | fn parse_f64(&mut self) -> Result<f64, ParseError<'src>> {
  function parse_net (line 72) | fn parse_net(&mut self) -> Result<Net, ParseError<'src>> {
  function parse_net_inner (line 80) | pub fn parse_net_inner(&mut self) -> Result<Net, ParseError<'src>> {
  function parse_pair (line 89) | pub(super) fn parse_pair(&mut self) -> Result<(Tree, Tree), ParseError<'...
  function parse_tree (line 96) | fn parse_tree(&mut self) -> Result<Tree, ParseError<'src>> {

FILE: ivy/src/repl.rs
  type Repl (line 18) | pub struct Repl<'host, 'ctx, 'ivm, 'ext> {
  function new (line 25) | pub fn new(host: &'host mut Host<'ivm>, ivm: &'ctx mut IVM<'ivm, 'ext>) ...
  function exec (line 30) | pub fn exec<'s>(&mut self, line: &'s str) -> Result<(), ParseError<'s>> {
  function exec_pair (line 42) | pub fn exec_pair(&mut self, pair: (Tree, Tree)) {
  function inject_to (line 49) | fn inject_to(&mut self, tree: Tree, to: Wire<'ivm>) {
  function inject (line 66) | fn inject(&mut self, tree: Tree) -> Port<'ivm> {
  method fmt (line 111) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: lsp/client/src/extension.ts
  function activate (line 43) | async function activate(context: vscode.ExtensionContext) {
  function activateLsp (line 48) | function activateLsp(context: vscode.ExtensionContext) {
  function activateHighlighting (line 90) | async function activateHighlighting(context: vscode.ExtensionContext) {
  function deactivate (line 144) | function deactivate() {
  function applyChanges (line 148) | function applyChanges(tree: Tree, changes: readonly vscode.TextDocumentC...
  class TreeSitterSemanticTokensProvider (line 180) | class TreeSitterSemanticTokensProvider implements vscode.DocumentSemanti...
    method constructor (line 181) | constructor(public onDidChangeSemanticTokens: vscode.Event<void>) {}
    method provideDocumentSemanticTokens (line 183) | async provideDocumentSemanticTokens(

FILE: lsp/src/lib.rs
  type Backend (line 28) | struct Backend {
    method refresh (line 37) | async fn refresh(&self) {
  type Lsp (line 92) | struct Lsp {
    method workspace_symbols (line 98) | fn workspace_symbols(&self, params: WorkspaceSymbolParams) -> Option<V...
    method document_symbols (line 123) | fn document_symbols(&self, params: DocumentSymbolParams) -> Option<Doc...
    method definitions (line 165) | fn definitions(&self, params: GotoDefinitionParams) -> Option<GotoDefi...
    method references (line 171) | fn references(&self, params: ReferenceParams) -> Option<Vec<Location>> {
    method occurrences (line 181) | fn occurrences(&self, params: DocumentHighlightParams) -> Option<Vec<D...
    method hover (line 197) | fn hover(&self, params: HoverParams) -> Option<Hover> {
    method lookup_span (line 226) | fn lookup_span<'a, T>(&self, map: &'a BTreeMap<Span, T>, span: Span) -...
    method get_def (line 232) | fn get_def(&self, span: Span) -> Option<(Span, Span)> {
    method file_to_uri (line 237) | fn file_to_uri(&self, file: FileId) -> Url {
    method uri_to_file_id (line 243) | fn uri_to_file_id(&self, uri: Url) -> Option<FileId> {
    method byte_to_position (line 247) | fn byte_to_position(&self, file: FileId, byte: usize) -> Position {
    method span_to_range (line 252) | fn span_to_range(&self, span: Span) -> Range {
    method position_to_byte (line 259) | fn position_to_byte(&self, file: FileId, position: Position) -> Option...
    method position_to_span (line 266) | fn position_to_span(&self, file: FileId, position: Position) -> Option...
    method document_position_to_span (line 271) | fn document_position_to_span(&self, doc_pos: TextDocumentPositionParam...
    method span_to_location (line 276) | fn span_to_location(&self, span: Span) -> Location {
    method diag_to_diagnostic (line 280) | fn diag_to_diagnostic(&self, diag: &Diag, severity: DiagnosticSeverity...
  method initialize (line 298) | async fn initialize(&self, params: InitializeParams) -> Result<Initializ...
  method initialized (line 331) | async fn initialized(&self, _: InitializedParams) {
  method did_save (line 335) | async fn did_save(&self, _: DidSaveTextDocumentParams) {
  method did_open (line 339) | async fn did_open(&self, params: DidOpenTextDocumentParams) {
  method did_change (line 346) | async fn did_change(&self, params: DidChangeTextDocumentParams) {
  method did_close (line 353) | async fn did_close(&self, params: DidCloseTextDocumentParams) {
  method symbol (line 358) | async fn symbol(&self, params: WorkspaceSymbolParams) -> Result<Option<V...
  method document_symbol (line 362) | async fn document_symbol(
  method goto_definition (line 369) | async fn goto_definition(
  method references (line 376) | async fn references(&self, params: ReferenceParams) -> Result<Option<Vec...
  method document_highlight (line 380) | async fn document_highlight(
  method hover (line 387) | async fn hover(&self, params: HoverParams) -> Result<Option<Hover>> {
  method formatting (line 391) | async fn formatting(&self, params: DocumentFormattingParams) -> Result<O...
  method shutdown (line 414) | async fn shutdown(&self) -> Result<()> {
  function lsp (line 421) | pub async fn lsp(

FILE: lsp/tree-sitter-vine/grammar.js
  constant BINARY_OP_TABLE (line 62) | const BINARY_OP_TABLE = [
  constant LOGICAL_OP_TABLE (line 78) | const LOGICAL_OP_TABLE = [

FILE: tests/verify/regex.rs
  function main (line 11) | fn main() {

FILE: util/src/bicycle.rs
  type BicycleState (line 8) | pub struct BicycleState(Cell<usize>);
    method reset (line 21) | pub fn reset(&self) {
  method fmt (line 11) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Bicycle (line 26) | pub trait Bicycle {
    method state (line 28) | fn state(&mut self, node: Self::Node) -> &BicycleState;
    method visit (line 29) | fn visit(&mut self, node: Self::Node, recurse: impl FnMut(&mut Self, S...
    method visit_all (line 31) | fn visit_all(&mut self, nodes: impl IntoIterator<Item = Self::Node> + ...
  function visit (line 41) | fn visit<B: Bicycle + ?Sized>(bi: &mut B, node: B::Node, depth: usize) -...
  function _visit (line 65) | fn _visit<B: Bicycle + ?Sized>(bi: &mut B, node: B::Node, depth: usize) ...

FILE: util/src/idx.rs
  type Idx (line 16) | pub trait Idx: Copy + Eq + Ord + Hash + IsEnabled + From<usize> + Into<u...
  type IdxVec (line 50) | pub struct IdxVec<I: Idx, T> {
  function new (line 57) | pub const fn new() -> Self {
  function repeat (line 62) | pub fn repeat(value: T, len: usize) -> Self
  function len (line 70) | pub fn len(&self) -> usize {
  function is_empty (line 75) | pub fn is_empty(&self) -> bool {
  function range (line 80) | pub fn range(&self) -> Range<I> {
  function next_index (line 85) | pub fn next_index(&self) -> I {
  function push (line 91) | pub fn push(&mut self, value: T) -> I {
  function push_to (line 98) | pub fn push_to(&mut self, index: I, value: T) {
  function get (line 104) | pub fn get(&self, index: I) -> Option<&T> {
  function get_mut (line 109) | pub fn get_mut(&mut self, index: I) -> Option<&mut T> {
  function last (line 114) | pub fn last(&self) -> Option<&T> {
  function last_mut (line 119) | pub fn last_mut(&mut self) -> Option<&mut T> {
  function pop (line 124) | pub fn pop(&mut self) -> Option<T> {
  function get2_mut (line 128) | pub fn get2_mut(&mut self, a: I, b: I) -> Option<(&mut T, &mut T)> {
  function iter (line 145) | pub fn iter(&self) -> Iter<'_, I, T> {
  function iter_mut (line 150) | pub fn iter_mut(&mut self) -> IterMut<'_, I, T> {
  function slice (line 155) | pub fn slice(&self, range: Range<I>) -> slice::Iter<'_, T> {
  function slice_mut (line 160) | pub fn slice_mut(&mut self, range: Range<I>) -> slice::IterMut<'_, T> {
  function keys (line 165) | pub fn keys(&self) -> RangeIter<I> {
  function keys_from (line 170) | pub fn keys_from(&self, index: I) -> impl Iterator<Item = I> + Clone + u...
  function into_values (line 175) | pub fn into_values(self) -> vec::IntoIter<T> {
  function values (line 180) | pub fn values(&self) -> slice::Iter<'_, T> {
  function values_mut (line 185) | pub fn values_mut(&mut self) -> slice::IterMut<'_, T> {
  function get_or_extend (line 189) | pub fn get_or_extend(&mut self, index: I) -> &mut T
  function get_or_extend_with (line 196) | pub fn get_or_extend_with(&mut self, index: I, f: impl FnMut() -> T) -> ...
  function truncate (line 204) | pub fn truncate(&mut self, len: usize) {
  function clear (line 208) | pub fn clear(&mut self) {
  function drain (line 212) | pub fn drain(&mut self) -> Map<Enumerate<vec::Drain<'_, T>>, MapEntry<I,...
  function fill (line 216) | pub fn fill(&mut self, value: T)
  type Output (line 225) | type Output = T;
  function index (line 227) | fn index(&self, index: I) -> &T {
  function index_mut (line 233) | fn index_mut(&mut self, index: I) -> &mut T {
  method fmt (line 239) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 247) | fn from(vec: Vec<T>) -> Self {
  function from (line 253) | fn from(value: IdxVec<I, T>) -> Self {
  function from (line 259) | fn from(value: [T; N]) -> Self {
  method default (line 265) | fn default() -> Self {
  function map_entry (line 270) | fn map_entry<I: Idx, T>((index, value): (usize, T)) -> (I, T) {
  type MapEntry (line 274) | type MapEntry<I, T> = fn((usize, T)) -> (I, T);
  type IntoIter (line 275) | pub type IntoIter<I, T> = Map<Enumerate<vec::IntoIter<T>>, MapEntry<I, T>>;
  type Iter (line 276) | pub type Iter<'a, I, T> = Map<Enumerate<slice::Iter<'a, T>>, MapEntry<I,...
  type IterMut (line 277) | pub type IterMut<'a, I, T> = Map<Enumerate<slice::IterMut<'a, T>>, MapEn...
  type Item (line 280) | type Item = (I, T);
  type IntoIter (line 281) | type IntoIter = IntoIter<I, T>;
  method into_iter (line 282) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 288) | type Item = (I, &'a T);
  type IntoIter (line 289) | type IntoIter = Iter<'a, I, T>;
  method into_iter (line 290) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 296) | type Item = (I, &'a mut T);
  type IntoIter (line 297) | type IntoIter = IterMut<'a, I, T>;
  method into_iter (line 298) | fn into_iter(self) -> Self::IntoIter {
  function from_iter (line 304) | fn from_iter<It: IntoIterator<Item = T>>(iter: It) -> Self {
  type RangeIter (line 309) | pub type RangeIter<I> = Map<Range<usize>, fn(usize) -> I>;
  type RangeExt (line 310) | pub trait RangeExt<I: Idx> {
    method iter (line 311) | fn iter(&self) -> RangeIter<I>;
    method get (line 312) | fn get(&self, i: usize) -> I;
  function iter (line 316) | fn iter(&self) -> RangeIter<I> {
  function get (line 320) | fn get(&self, i: usize) -> I {
  type Counter (line 328) | pub struct Counter<I: Idx>(pub I);
  function next (line 333) | pub fn next(&mut self) -> I {
  function chunk (line 339) | pub fn chunk(&mut self, len: usize) -> Range<I> {
  function peek_next (line 346) | pub fn peek_next(&self) -> I {
  function count (line 350) | pub fn count(&self) -> usize {
  function reset (line 354) | pub fn reset(&mut self)

FILE: util/src/lexer.rs
  type LexerState (line 7) | pub struct LexerState<'src> {
  function new (line 17) | pub fn new(src: &'src str) -> Self {
  function bump (line 23) | pub fn bump(&mut self) {
  function teleport (line 30) | pub fn teleport(&mut self, offset: usize) {
  type Lex (line 36) | pub trait Lex<'src> {
    method state (line 40) | fn state(&self) -> &LexerState<'src>;
    method state_mut (line 41) | fn state_mut(&mut self) -> &mut LexerState<'src>;
    method lex (line 43) | fn lex(&mut self) -> Result<Self::Token, Self::Error>;
    method src (line 45) | fn src(&self) -> &'src str {
    method range (line 49) | fn range(&self) -> Range<usize> {
    method slice (line 54) | fn slice(&self) -> &'src str {
    method offset (line 58) | fn offset(&self) -> usize {
    method bump (line 62) | fn bump(&mut self) -> Option<char> {
    method eat (line 67) | fn eat(&mut self, char: char) -> bool {
    method start_token (line 76) | fn start_token(&mut self) {
    method bump_ok (line 81) | fn bump_ok(&mut self, token: Self::Token) -> Result<Self::Token, Self:...
    method teleport (line 86) | fn teleport(&mut self, offset: usize) {
    method char (line 90) | fn char(&self) -> Option<char> {
    method bump_while (line 94) | fn bump_while(&mut self, f: impl Fn(char) -> bool) -> usize {
    method skip_whitespace (line 103) | fn skip_whitespace(&mut self) {
    method skip_block_comment_content (line 107) | fn skip_block_comment_content(&mut self) {
  type Token (line 131) | pub trait Token: Copy + Eq + Debug {
    method into_u8 (line 132) | fn into_u8(self) -> u8;
  type TokenSet (line 136) | pub struct TokenSet<T: Token> {
  method default (line 143) | fn default() -> Self {
  function reset (line 149) | pub fn reset(&mut self) {
  function add (line 155) | pub fn add(&mut self, token: T) {
  function start_group (line 165) | pub fn start_group(&mut self, token: T) {
  function end_group (line 170) | pub fn end_group(&mut self) {
  method fmt (line 176) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 182) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: util/src/nat.rs
  type Nat (line 2) | pub struct Nat(pub Vec<u32>);
    constant ZERO (line 5) | pub const ZERO: Nat = Nat(Vec::new());
    method add_u32 (line 7) | pub fn add_u32(&mut self, mut n: u32) {
    method mul_u32 (line 21) | pub fn mul_u32(&mut self, n: u32) {

FILE: util/src/parser.rs
  type ParserState (line 7) | pub struct ParserState<'src, L: Lex<'src, Token: Token>> {
  function new (line 15) | pub fn new(mut lexer: L) -> Result<Self, L::Error> {
  type Parse (line 20) | pub trait Parse<'src> {
    method state (line 25) | fn state(&mut self) -> &mut ParserState<'src, Self::Lexer>;
    method unexpected_error (line 27) | fn unexpected_error(&self) -> Self::Error;
    method lexer (line 29) | fn lexer<'a>(&'a mut self) -> &'a mut Self::Lexer
    method bump (line 36) | fn bump(&mut self) -> Result<(), Self::Error> {
    method check (line 43) | fn check(&mut self, kind: Self::Token) -> bool {
    method eat (line 48) | fn eat(&mut self, kind: Self::Token) -> Result<bool, Self::Error> {
    method check_then (line 56) | fn check_then<T>(
    method eat_then (line 64) | fn eat_then<T>(
    method expect (line 72) | fn expect(&mut self, kind: Self::Token) -> Result<&'src str, Self::Err...
    method unexpected (line 82) | fn unexpected<T>(&self) -> Result<T, Self::Error> {
    method teleport (line 86) | fn teleport(&mut self, offset: usize) -> Result<(), Self::Error> {
    method parse_delimited (line 91) | fn parse_delimited<T>(
    method parse_u32_like (line 122) | fn parse_u32_like(
    method parse_nat_like (line 141) | fn parse_nat_like(
    method extract_radix (line 161) | fn extract_radix(bytes: &[u8]) -> (u32, &[u8]) {
    method parse_f32_like (line 171) | fn parse_f32_like(
    method parse_f64_like (line 179) | fn parse_f64_like(
  type Delimiters (line 188) | pub struct Delimiters<T: Token> {

FILE: util/src/unwrap_vec.rs
  function unwrap_vec (line 5) | pub fn unwrap_vec<T>(vec: Vec<Option<T>>) -> Vec<T> {
  function unwrap_idx_vec (line 15) | pub fn unwrap_idx_vec<I: Idx, T>(vec: IdxVec<I, Option<T>>) -> IdxVec<I,...

FILE: vine/src/compiler.rs
  type Compiler (line 35) | pub struct Compiler {
    method new (line 53) | pub fn new(debug: bool, config: HashMap<String, String>) -> Self {
    method check (line 57) | pub fn check(&mut self, hooks: impl Hooks) -> Result<(), ErrorGuarante...
    method compile (line 62) | pub fn compile(&mut self, hooks: impl Hooks) -> Result<Nets, ErrorGuar...
    method _compile (line 67) | fn _compile(
    method _check (line 76) | fn _check(
    method nets_from (line 132) | pub fn nets_from(&mut self, checkpoint: &Checkpoint) -> Nets {
    method entrypoint_name (line 180) | pub fn entrypoint_name(&mut self, fragment_id: FragmentId) -> String {
    method insert_main_net (line 188) | pub fn insert_main_net(&mut self, nets: &mut Nets, main: FragmentId) {
  type Hooks (line 194) | pub trait Hooks {
    method chart (line 195) | fn chart(&mut self, _charter: &mut Charter<'_>) {}
    method pre_resolve (line 196) | fn pre_resolve(&mut self, _resolver: &mut Resolver<'_>) {}
    method resolve (line 197) | fn resolve(&mut self, _resolver: &mut Resolver<'_>) {}
    method distill (line 198) | fn distill(&mut self, _fragment_id: FragmentId, _vir: &mut Vir) {}

FILE: vine/src/components/analyzer.rs
  function analyze (line 22) | pub fn analyze(chart: &Chart, diags: &mut Diags, span: Span, vir: &mut V...
  type Analyzer (line 45) | struct Analyzer<'a> {
  constant PASS (line 68) | pub const PASS: Self = EffectVar(0);
  function analyze (line 72) | fn analyze(&mut self) {
  function sweep (line 85) | fn sweep(&mut self, interface_id: InterfaceId) {
  function build (line 102) | fn build(&mut self) {
  function process_local (line 209) | fn process_local(&mut self, local: Local, declared: Vec<StageId>) {
  function fill_segments (line 221) | fn fill_segments(&mut self, local: Local, declared: Vec<StageId>) {
  function fixed_point (line 239) | fn fixed_point(&mut self, inv: Inverted) {
  function set_wires (line 257) | fn set_wires(&mut self, local: Local, inv: Inverted, fork: bool) {
  function new_relation (line 280) | fn new_relation(&mut self, a: EffectVar, b: EffectVar, c: EffectVar, o: ...
  function new_var (line 287) | fn new_var(&mut self) -> EffectVar {
  function mark_dirty (line 294) | fn mark_dirty(&mut self, var: EffectVar) {
  function get_transfer (line 302) | fn get_transfer(&mut self, interface: InterfaceId) -> (EffectVar, Effect...
  function report_errors (line 313) | fn report_errors(&mut self, local: Local, info: &VirLocal) {
  method effect (line 407) | fn effect(&self, inv: Inverted, fork: bool) -> Effect {

FILE: vine/src/components/analyzer/effect.rs
  type Effect (line 5) | pub enum Effect {
    method join (line 65) | pub fn join(self: Effect, other: Effect) -> Effect {
    method union (line 69) | pub fn union(self: Effect, other: Effect) -> Effect {
    method read (line 73) | pub fn read(self) -> bool {
    method pass (line 77) | pub fn pass(self) -> bool {
    method barrier (line 81) | pub fn barrier(self) -> bool {
    method write (line 85) | pub fn write(self) -> bool {
  constant JOIN (line 35) | const JOIN: &[[Effect; 11]; 11] = &[
  constant UNION (line 50) | const UNION: &[[Effect; 11]; 11] = &[
  function effects (line 94) | fn effects() -> impl Iterator<Item = Effect> {
  function join_identity (line 99) | fn join_identity() {
  function join_associative (line 107) | fn join_associative() {
  function join_idempotent (line 118) | fn join_idempotent() {
  function union_identity (line 125) | fn union_identity() {
  function union_commutative (line 133) | fn union_commutative() {
  function union_associative (line 142) | fn union_associative() {
  function union_idempotent (line 153) | fn union_idempotent() {
  function distributive (line 160) | fn distributive() {

FILE: vine/src/components/charter.rs
  type Charter (line 15) | pub struct Charter<'a> {
  function chart (line 22) | pub fn chart(&mut self, modules: Vec<Module>) {
  function new_def (line 46) | pub(crate) fn new_def(&mut self, name: Ident, path: String, parent: Opti...
  function chart_mod_kind (line 70) | pub(crate) fn chart_mod_kind(
  function chart_item (line 91) | pub fn chart_item(
  function chart_attrs (line 171) | pub(crate) fn chart_attrs(&mut self, vis: VisId, item: ChartedItem, attr...
  function chart_unsafe (line 284) | pub(crate) fn chart_unsafe(&mut self, span: Span, item: ChartedItem) {
  function chart_child (line 307) | pub(crate) fn chart_child(
  function resolve_vis (line 351) | pub(crate) fn resolve_vis(&mut self, base: DefId, vis: Vis) -> VisId {
  function ensure_implemented (line 368) | pub(crate) fn ensure_implemented<T: From<ErrorGuaranteed>>(
  function define_value (line 376) | pub(crate) fn define_value(&mut self, span: Span, def: DefId, vis: VisId...
  function define_type (line 385) | pub(crate) fn define_type(&mut self, span: Span, def: DefId, vis: VisId,...
  function define_pattern (line 394) | pub(crate) fn define_pattern(
  function define_trait (line 409) | pub(crate) fn define_trait(&mut self, span: Span, def: DefId, vis: VisId...
  function define_impl (line 418) | pub(crate) fn define_impl(&mut self, span: Span, def: DefId, vis: VisId,...
  type ChartedItem (line 425) | pub enum ChartedItem {
    method def (line 441) | pub fn def(&self) -> Option<DefId> {
  function extract_subitems (line 458) | fn extract_subitems(item: &mut Item) -> Vec<Item> {
  type ExtractItems (line 467) | pub struct ExtractItems {
    method visit_item (line 472) | fn visit_item(&mut self, item: &mut Item) {

FILE: vine/src/components/distiller.rs
  type Distiller (line 28) | pub struct Distiller<'r> {
  type TargetDistillation (line 50) | pub(crate) struct TargetDistillation {
  type Return (line 57) | pub(crate) struct Return {
  type Poly (line 63) | pub(crate) enum Poly<T = Port> {
  function new (line 71) | pub fn new(
  function distill_fragment (line 96) | pub fn distill_fragment(&mut self, fragment: &Fragment) -> Vir {
  function new_stage (line 136) | pub(crate) fn new_stage(
  function new_layer (line 157) | pub(crate) fn new_layer(&mut self) -> Layer {
  function child_layer (line 162) | pub(crate) fn child_layer(&mut self, parent_stage: &mut Stage, span: Spa...
  function root_layer (line 170) | fn root_layer(&mut self, span: Span) -> (Layer, Stage) {
  function finish_stage (line 176) | pub(crate) fn finish_stage(&mut self, stage: Stage) -> StageId {
  function finish_layer (line 182) | pub(crate) fn finish_layer(&mut self, layer: Layer) {
  function new_unconditional_stage (line 187) | pub(crate) fn new_unconditional_stage(&mut self, layer: &mut Layer, span...
  function new_local (line 195) | pub(crate) fn new_local(&mut self, stage: &mut Stage, span: Span, ty: Ty...
  function find_impl (line 201) | pub(crate) fn find_impl(&mut self, span: Span, ty: &ImplType, basic: boo...
  function distill_vec (line 214) | pub(crate) fn distill_vec<T>(
  function distill_vec_pair (line 229) | pub(crate) fn distill_vec_pair<T>(
  function distill_expr_nil (line 246) | pub(crate) fn distill_expr_nil(&mut self, stage: &mut Stage, expr: &TirE...
  function distill_expr_value (line 262) | pub(crate) fn distill_expr_value(&mut self, stage: &mut Stage, expr: &Ti...
  function distill_expr_space (line 327) | pub(crate) fn distill_expr_space(&mut self, stage: &mut Stage, expr: &Ti...
  function distill_expr_place (line 346) | pub(crate) fn distill_expr_place(&mut self, stage: &mut Stage, expr: &Ti...
  function distill_expr_poly (line 367) | pub(crate) fn distill_expr_poly(&mut self, stage: &mut Stage, expr: &Tir...
  function distill_pat_uninit (line 386) | pub(crate) fn distill_pat_uninit(&mut self, stage: &mut Stage, pat: &Tir...
  function distill_pat_loop (line 406) | pub(crate) fn distill_pat_loop(&mut self, stage: &mut Stage, pat: &TirPa...
  function distill_pat_value (line 426) | pub(crate) fn distill_pat_value(&mut self, stage: &mut Stage, pat: &TirP...
  function distill_pat_space (line 449) | pub(crate) fn distill_pat_space(&mut self, stage: &mut Stage, pat: &TirP...
  function distill_pat_place (line 470) | pub(crate) fn distill_pat_place(&mut self, stage: &mut Stage, pat: &TirP...

FILE: vine/src/components/emitter.rs
  function emit (line 19) | pub fn emit(
  type Emitter (line 45) | pub(crate) struct Emitter<'a> {
  function emit_stage (line 61) | pub fn emit_stage(&mut self, stage: &Stage) -> Option<TemplateStage> {
  function emit_transfer (line 80) | pub fn emit_transfer(&mut self, transfer: &Transfer) {
  function inline_stage (line 116) | fn inline_stage(&mut self, stage: &Stage) {
  function _emit_stage (line 124) | fn _emit_stage(&mut self, stage: &Stage) {
  function emit_interface (line 135) | fn emit_interface(&mut self, interface: &Interface, interior: bool) -> T...
  function emit_step (line 167) | fn emit_step(&mut self, step: &Step) {
  function emit_link (line 203) | fn emit_link(&mut self, a: &Port, b: &Port) {
  function emit_ext_fn (line 209) | fn emit_ext_fn(
  function emit_fn_rel (line 229) | pub(crate) fn emit_fn_rel(&mut self, rel: FnRelId) -> Tree {
  function emit_const_rel (line 235) | pub(crate) fn emit_const_rel(&mut self, rel: ConstRelId) -> Tree {
  function emit_stage_rel (line 241) | pub(crate) fn emit_stage_rel(&mut self, stage: StageId) -> Tree {
  function emit_port (line 247) | pub(crate) fn emit_port(&mut self, port: &Port) -> Tree {
  function emit_header (line 259) | fn emit_header(&mut self, header: &Header, root: Tree) -> Tree {
  function new_wire (line 295) | pub(crate) fn new_wire(&mut self) -> (Tree, Tree) {
  function main_net (line 301) | pub(crate) fn main_net(debug: bool, main: Tree) -> Net {

FILE: vine/src/components/finder.rs
  type Finder (line 20) | pub struct Finder<'a> {
  type FinderCache (line 32) | pub struct FinderCache {
  type FlexImpls (line 37) | pub struct FlexImpls {
  constant STEPS_LIMIT (line 44) | const STEPS_LIMIT: u32 = 2_000;
  type Error (line 47) | pub(crate) enum Error {
    method from (line 53) | fn from(err: ErrorGuaranteed) -> Self {
  function new (line 59) | pub fn new(
  function find_method (line 71) | pub fn find_method(
  function find_method_candidates (line 101) | fn find_method_candidates(
  function find_flex (line 117) | pub fn find_flex(&mut self, types: &mut Types, ty: Type) -> Result<FlexI...
  function _find_flex (line 121) | fn _find_flex(&mut self, types: &mut Types, ty: Type) -> Result<FlexImpl...
  function find_impl (line 194) | pub fn find_impl(&mut self, types: &mut Types, query: &ImplType, basic: ...
  function try_find_impl (line 200) | pub fn try_find_impl(
  function _find_impl (line 233) | fn _find_impl(
  function find_impl_params (line 275) | pub(crate) fn find_impl_params(
  function find_subimpls (line 289) | fn find_subimpls(
  function find_impl_candidates (line 312) | fn find_impl_candidates(
  function step (line 340) | fn step(&mut self) -> Result<(), Error> {
  function find_auto_impls (line 345) | fn find_auto_impls(
  function general_candidates (line 378) | fn general_candidates(&self) -> &candidates::CandidateSet {
  function get_candidates (line 382) | fn get_candidates<T: Copy + Hash + Ord>(

FILE: vine/src/components/finder/candidates.rs
  type CandidateSets (line 21) | pub struct CandidateSets {
    method build_since (line 84) | pub fn build_since(&mut self, chart: &Chart, sigs: &Signatures) {
    method get_within (line 97) | pub fn get_within(&self, def: DefId) -> &CandidateSet {
    method get_within_ancestors (line 101) | pub fn get_within_ancestors(&self, def: DefId) -> &CandidateSet {
    method get (line 105) | fn get<'a>(&'a self, handle: &'a CandidateSetHandle) -> &'a CandidateS...
    method get_owned (line 113) | fn get_owned(&self, handle: CandidateSetHandle) -> CandidateSet {
    method get_mut (line 121) | fn get_mut<'a>(&self, handle: &'a mut CandidateSetHandle) -> &'a mut C...
    method insert (line 127) | fn insert(&mut self, handle: CandidateSetHandle) -> CandidateSetHandle {
    method merge (line 131) | fn merge(&self, chart: &Chart, a: &mut CandidateSetHandle, vis: VisId,...
  type CandidateSetHandle (line 31) | pub enum CandidateSetHandle {
  type Level (line 41) | pub(crate) enum Level {
  type CandidateSet (line 51) | pub struct CandidateSet {
  type VisSet (line 58) | pub enum VisSet {
    method insert (line 70) | pub fn insert(&mut self, vis: VisId) {
    method merge_vis_sets (line 322) | fn merge_vis_sets(&mut self, chart: &Chart, vis: VisId, b: &VisSet) {
  method default (line 64) | fn default() -> Self {
  type CandidateSetBuilder (line 166) | pub struct CandidateSetBuilder<'a> {
  type NodeState (line 176) | struct NodeState {
  type Node (line 181) | type Node = (DefId, Level);
  function visit_all (line 184) | fn visit_all(&mut self) {
  function visit (line 192) | fn visit(&mut self, node: Node) -> Option<usize> {
  function for_each_child (line 248) | fn for_each_child(&mut self, (def_id, level): Node, mut f: impl FnMut(&m...
  function add_direct_candidate (line 294) | fn add_direct_candidate(&self, set: &mut CandidateSetHandle, (def_id, le...

FILE: vine/src/components/lexer.rs
  type Token (line 13) | pub enum Token {
    method fmt (line 344) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Lexer (line 114) | pub struct Lexer<'src> {
  function new (line 120) | pub fn new(file: FileId, src: &'src str) -> Self {
  function span (line 124) | pub fn span(&self) -> Span {
  type Token (line 131) | type Token = Token;
    method fmt (line 344) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 132) | type Error = Diag;
  function state (line 134) | fn state(&self) -> &LexerState<'src> {
  function state_mut (line 138) | fn state_mut(&mut self) -> &mut LexerState<'src> {
  function lex (line 142) | fn lex(&mut self) -> Result<Self::Token, Self::Error> {
  function keyword (line 292) | fn keyword(str: &str) -> Option<Token> {
  function is_ident (line 332) | pub fn is_ident(str: &str) -> bool {
  method into_u8 (line 338) | fn into_u8(self) -> u8 {

FILE: vine/src/components/loader.rs
  type Loader (line 22) | pub struct Loader<'a, F: FS> {
  type Module (line 30) | pub struct Module {
  function new (line 37) | pub fn new(
  function load_main_mod (line 51) | pub fn load_main_mod(&mut self, name: Ident, path: F::Path) {
  function load_mod (line 55) | pub fn load_mod(&mut self, name: Ident, path: F::Path) {
  function _load_mod (line 59) | fn _load_mod(&mut self, name: Ident, path: F::Path, main: bool) {
  function load_file (line 75) | fn load_file(
  function error_mod (line 100) | fn error_mod(&mut self, diag: Diag) -> ModKind {
  function load_dir (line 104) | fn load_dir(&mut self, span: Span, name: &Ident, path: DisplayPath<F>) -...
  function load_child (line 109) | fn load_child(&mut self, span: Span, base: Option<&DisplayPath<F>>, name...
  function load_children (line 136) | fn load_children<'t>(&mut self, base: Option<&DisplayPath<F>>, visitee: ...
  type LoadChildren (line 141) | struct LoadChildren<'a, 'b, F: FS> {
  function visit_item (line 147) | fn visit_item(&mut self, item: &mut Item) {
  type DisplayFS (line 158) | struct DisplayFS<F>(F);
  type DisplayPath (line 160) | struct DisplayPath<F: FS> {
  type FS (line 211) | pub trait FS {
    type Path (line 166) | type Path = DisplayPath<F>;
    method kind (line 168) | fn kind(&mut self, path: &Self::Path) -> Option<EntryKind> {
    method child_dir (line 172) | fn child_dir(&mut self, path: &Self::Path, name: &Ident) -> Self::Path {
    method child_file (line 179) | fn child_file(&mut self, path: &Self::Path, name: &Ident) -> Self::Path {
    method read_file (line 186) | fn read_file(&mut self, path: &Self::Path) -> Option<String> {
    type Path (line 192) | type Path = F::Path;
    method kind (line 194) | fn kind(&mut self, path: &Self::Path) -> Option<EntryKind> {
    method child_dir (line 198) | fn child_dir(&mut self, path: &Self::Path, name: &Ident) -> Self::Path {
    method child_file (line 202) | fn child_file(&mut self, path: &Self::Path, name: &Ident) -> Self::Path {
    method read_file (line 206) | fn read_file(&mut self, path: &Self::Path) -> Option<String> {
    method kind (line 214) | fn kind(&mut self, path: &Self::Path) -> Option<EntryKind>;
    method child_dir (line 216) | fn child_dir(&mut self, path: &Self::Path, name: &Ident) -> Self::Path;
    method child_file (line 217) | fn child_file(&mut self, path: &Self::Path, name: &Ident) -> Self::Path;
    method read_file (line 219) | fn read_file(&mut self, path: &Self::Path) -> Option<String>;
    type Path (line 226) | type Path = PathBuf;
    method kind (line 228) | fn kind(&mut self, path: &Self::Path) -> Option<EntryKind> {
    method child_dir (line 239) | fn child_dir(&mut self, path: &Self::Path, name: &Ident) -> Self::Path {
    method child_file (line 243) | fn child_file(&mut self, path: &Self::Path, name: &Ident) -> Self::Path {
    method read_file (line 249) | fn read_file(&mut self, path: &Self::Path) -> Option<String> {
  type RealFS (line 223) | pub struct RealFS;
    method detect_name (line 255) | pub fn detect_name(path: &Path) -> Option<Ident> {
  type EntryKind (line 263) | pub enum EntryKind {

FILE: vine/src/components/matcher.rs
  function distill_pattern_match (line 18) | pub fn distill_pattern_match(
  type MatchVarForm (line 40) | pub(crate) enum MatchVarForm {
  type Row (line 48) | pub struct Row<'p> {
  type MatchVar (line 55) | pub(crate) struct MatchVar {
  type MatchVarKind (line 61) | pub(crate) enum MatchVarKind {
    method form (line 70) | fn form(&self) -> MatchVarForm {
  function new (line 79) | pub fn new(pat: Option<&'p TirPat>, arm: InterfaceId) -> Self {
  function add (line 87) | fn add(&mut self, var: VarId, pat: &'p TirPat) {
  type Matcher (line 97) | pub(crate) struct Matcher<'d, 'r> {
  function distill_rows (line 104) | pub(crate) fn distill_rows<'p>(
  function eliminate_col (line 152) | pub(crate) fn eliminate_col<
  function new_var (line 178) | pub(crate) fn new_var(
  function distill_row (line 190) | fn distill_row<'p>(&mut self, stage: &mut Stage, vars: &IdxVec<VarId, Ma...
  function borrow_var (line 209) | pub(crate) fn borrow_var(
  function restore_var (line 221) | pub(crate) fn restore_var(
  function take_var (line 239) | pub(crate) fn take_var(
  function set_var (line 269) | fn set_var(&mut self, stage: &mut Stage, var: &MatchVar) -> Option<Port> {

FILE: vine/src/components/normalizer.rs
  function normalize (line 22) | pub fn normalize(
  type Normalizer (line 65) | struct Normalizer<'a> {
  function normalize_layer (line 86) | fn normalize_layer(&mut self, layer: &Layer) {
  function layer_divergence (line 193) | fn layer_divergence(&mut self, layer: &Layer) -> LayerId {
  function step_divergence (line 211) | fn step_divergence(&mut self, step: &Step) -> LayerId {
  function update_open_wires (line 224) | fn update_open_wires(open_wires: &mut BTreeMap<WireId, (Span, Type)>, po...

FILE: vine/src/components/parser.rs
  type Parser (line 21) | pub struct Parser<'src> {
  type Token (line 27) | type Token = Token;
  type Lexer (line 28) | type Lexer = Lexer<'src>;
  type Error (line 29) | type Error = Diag;
  function state (line 31) | fn state(&mut self) -> &mut ParserState<'src, Lexer<'src>> {
  function unexpected_error (line 35) | fn unexpected_error(&self) -> Diag {
  function new (line 45) | pub fn new(lexer: Lexer<'src>) -> Result<Self, Diag> {
  function parse (line 49) | pub fn parse(file: FileId, src: &'src str) -> Result<Vec<Item>, Diag> {
  function parse_item (line 58) | pub(crate) fn parse_item(&mut self) -> Result<Item, Diag> {
  function maybe_parse_item (line 62) | fn maybe_parse_item(&mut self) -> Result<Option<Item>, Diag> {
  function parse_vis (line 98) | pub(crate) fn parse_vis(&mut self) -> Result<Vis, Diag> {
  function parse_attr (line 113) | fn parse_attr(&mut self) -> Result<Attr, Diag> {
  function parse_ident (line 147) | pub fn parse_ident(&mut self) -> Result<Ident, Diag> {
  function parse_flex (line 152) | pub(crate) fn parse_flex(&mut self) -> Result<Flex, Diag> {
  function parse_exprs (line 164) | pub(crate) fn parse_exprs(&mut self) -> Result<Vec<Expr>, Diag> {
  function parse_expr (line 168) | pub(crate) fn parse_expr(&mut self) -> Result<Expr, Diag> {
  function maybe_parse_expr_bp (line 172) | pub(crate) fn maybe_parse_expr_bp(&mut self, bp: BP) -> Result<Option<Ex...
  function parse_expr_bp (line 185) | pub(crate) fn parse_expr_bp(&mut self, bp: BP) -> Result<Expr, Diag> {
  function maybe_parse_expr_prefix (line 192) | fn maybe_parse_expr_prefix(&mut self) -> Result<Option<Expr>, Diag> {
  function _maybe_parse_expr_prefix (line 201) | fn _maybe_parse_expr_prefix(&mut self, span: usize) -> Result<Option<Exp...
  function parse_expr_postfix (line 289) | fn parse_expr_postfix(&mut self, lhs: Expr, bp: BP) -> Result<Result<Exp...
  function parse_pats (line 414) | pub(crate) fn parse_pats(&mut self) -> Result<Vec<Pat>, Diag> {
  function parse_pat (line 418) | pub(crate) fn parse_pat(&mut self) -> Result<Pat, Diag> {
  function parse_pat_bp (line 422) | pub(crate) fn parse_pat_bp(&mut self, bp: BP) -> Result<Pat, Diag> {
  function parse_pat_prefix (line 433) | fn parse_pat_prefix(&mut self) -> Result<Pat, Diag> {
  function _parse_pat_prefix (line 440) | fn _parse_pat_prefix(&mut self, span: usize) -> Result<PatKind, Diag> {
  function parse_pat_postfix (line 471) | fn parse_pat_postfix(&mut self, lhs: Pat, bp: BP) -> Result<Result<PatKi...
  function parse_ty (line 479) | pub(crate) fn parse_ty(&mut self) -> Result<Ty, Diag> {
  function _parse_ty (line 486) | fn _parse_ty(&mut self, span: usize) -> Result<TyKind, Diag> {
  function parse_arrow_ty (line 522) | pub(crate) fn parse_arrow_ty(&mut self) -> Result<Option<Ty>, Diag> {
  function parse_impl (line 526) | pub(crate) fn parse_impl(&mut self) -> Result<Impl, Diag> {
  function _parse_impl (line 533) | fn _parse_impl(&mut self) -> Result<ImplKind, Diag> {
  function parse_trait (line 550) | pub(crate) fn parse_trait(&mut self) -> Result<Trait, Diag> {
  function _parse_trait (line 557) | fn _parse_trait(&mut self) -> Result<TraitKind, Diag> {
  function parse_stmt (line 570) | pub(crate) fn parse_stmt(&mut self) -> Result<Stmt, Diag> {
  function _parse_stmt (line 577) | fn _parse_stmt(&mut self) -> Result<StmtKind, Diag> {
  function start_span (line 620) | pub(crate) fn start_span(&self) -> usize {
  function end_span (line 624) | pub(crate) fn end_span(&self, span: usize) -> Span {
  function span (line 628) | pub(crate) fn span(&self) -> Span {
  type Delimiters (line 635) | pub(crate) type Delimiters = vine_util::parser::Delimiters<Token>;
  constant PAREN_COMMA (line 637) | pub(crate) const PAREN_COMMA: Delimiters = Delimiters {
  constant BRACE (line 643) | pub(crate) const BRACE: Delimiters =
  constant BRACE_COMMA (line 646) | pub(crate) const BRACE_COMMA: Delimiters = Delimiters {
  constant BRACKET_COMMA (line 652) | pub(crate) const BRACKET_COMMA: Delimiters = Delimiters {
  constant PATH (line 658) | pub(crate) const PATH: Delimiters =
  type Associativity (line 663) | enum Associativity {
  type BP (line 671) | pub(crate) enum BP {
    method inc (line 693) | const fn inc(self) -> Self {
    method permits (line 697) | pub(crate) fn permits(self, other: Self) -> bool {
  constant BINARY_OP_TABLE (line 703) | const BINARY_OP_TABLE: &[(BP, Associativity, Token, BinaryOp)] = &[
  constant COMPARISON_OP_TABLE (line 719) | const COMPARISON_OP_TABLE: &[(Token, ComparisonOp)] = &[

FILE: vine/src/components/resolver.rs
  type Resolver (line 33) | pub struct Resolver<'a> {
  type ScopeEntry (line 60) | pub(crate) struct ScopeEntry {
  type TargetInfo (line 67) | pub(crate) struct TargetInfo {
  type ScopeBinding (line 74) | pub(crate) enum ScopeBinding {
  function new (line 80) | pub fn new(
  function resolve_all (line 115) | pub fn resolve_all(&mut self) {
  function resolve_since (line 119) | pub(crate) fn resolve_since(&mut self, checkpoint: &Checkpoint) {
  function resolve_main (line 179) | fn resolve_main(&mut self, main_mod: DefId) {
  function _resolve_main (line 190) | fn _resolve_main(&mut self, main_mod: DefId) -> Result<ConcreteFnId, Dia...
  function initialize (line 203) | pub(crate) fn initialize(&mut self, def_id: DefId, generics_id: Generics...
  function _resolve_repl (line 220) | pub(crate) fn _resolve_repl(
  function expect_fn_sig (line 265) | pub(crate) fn expect_fn_sig(
  function expect_entrypoint_sig (line 282) | pub(crate) fn expect_entrypoint_sig(&mut self, concrete_fn_id: ConcreteF...
  function resolve_trait (line 303) | pub(crate) fn resolve_trait(&mut self, trait_: &Trait) -> ImplType {
  function resolve_impl_type (line 321) | pub(crate) fn resolve_impl_type(&mut self, impl_: &Impl, ty: &ImplType) ...
  function find_impl (line 332) | pub(crate) fn find_impl(&mut self, span: Span, ty: &ImplType, basic: boo...
  function bind (line 345) | pub(crate) fn bind(&mut self, ident: Ident, binding: ScopeBinding) {
  function enter_scope (line 360) | pub(crate) fn enter_scope(&mut self) {
  function exit_scope (line 364) | pub(crate) fn exit_scope(&mut self) {
  function finish_binding (line 380) | fn finish_binding(
  function error_expr (line 399) | pub(crate) fn error_expr(&mut self, span: Span, diag: Diag) -> TirExpr {
  function error_pat (line 404) | pub(crate) fn error_pat(&mut self, span: Span, diag: Diag) -> TirPat {
  function expect_type (line 409) | pub(crate) fn expect_type(
  function finish_fragment (line 426) | pub(crate) fn finish_fragment(
  function builtin_ty (line 450) | pub(crate) fn builtin_ty(
  function bool (line 463) | pub(crate) fn bool(&mut self, span: Span) -> Type {
  function builtin_fn (line 467) | pub(crate) fn builtin_fn<const N: usize>(
  function resolve_expr_type (line 488) | pub(crate) fn resolve_expr_type(&mut self, expr: &Expr, ty: Type) -> Tir...
  function resolve_expr (line 494) | pub(crate) fn resolve_expr(&mut self, expr: &Expr) -> TirExpr {
  function _resolve_expr (line 498) | pub(crate) fn _resolve_expr(&mut self, expr: &Expr) -> Result<TirExpr, D...
  function resolve_pat_type (line 565) | pub(crate) fn resolve_pat_type(&mut self, pat: &Pat, ty: Type) -> TirPat {
  function resolve_pat (line 574) | pub(crate) fn resolve_pat(&mut self, pat: &Pat) -> TirPat {
  function _resolve_pat (line 578) | pub(crate) fn _resolve_pat(&mut self, pat: &Pat) -> Result<TirPat, Diag> {
  function resolve_pat_sig (line 595) | pub(crate) fn resolve_pat_sig(&mut self, pat: &Pat, inference: bool) -> ...
  function resolve_ty (line 615) | pub(crate) fn resolve_ty(&mut self, ty: &Ty, inference: bool) -> Type {
  function resolve_arrow_ty (line 635) | pub(crate) fn resolve_arrow_ty(&mut self, span: Span, ty: &Option<Ty>, i...
  function resolve_test_fn (line 648) | pub(crate) fn resolve_test_fn(&mut self, concrete_fn_id: ConcreteFnId) {
  function safe (line 654) | pub(crate) fn safe<T>(&mut self, span: Span, f: impl FnOnce(&mut Self) -...
  function unsafe_ (line 671) | pub(crate) fn unsafe_(&mut self, span: Span) {

FILE: vine/src/components/specializer.rs
  type Specializer (line 21) | pub struct Specializer<'a> {
  function specialize_since (line 30) | pub fn specialize_since(&mut self, checkpoint: &Checkpoint) {
  function specialize (line 38) | fn specialize(&mut self, id: FragmentId, impl_args: Vec<ImplTree>) -> Sp...
  function instantiate_rels (line 58) | fn instantiate_rels(
  function instantiate_const_rel (line 74) | fn instantiate_const_rel(
  function instantiate_fn_rel (line 120) | fn instantiate_fn_rel(
  function instantiate_fn_id (line 152) | pub(crate) fn instantiate_fn_id(
  function instantiate_synthetic_item (line 221) | fn instantiate_synthetic_item(&mut self, item: SyntheticItem, impls: Vec...
  function _closure_stage (line 242) | fn _closure_stage(&self, fragment_id: FragmentId, closure_id: Option<Clo...
  function _closure_interface (line 249) | fn _closure_interface(
  function instantiate (line 262) | pub(crate) fn instantiate(

FILE: vine/src/components/synthesizer.rs
  type SyntheticImpl (line 25) | pub enum SyntheticImpl {
    method fn_ (line 424) | pub fn fn_(self, _: &Chart, fn_id: TraitFnId) -> SyntheticItem {
    method const_ (line 444) | pub fn const_(self, chart: &Chart, const_id: TraitConstId) -> Syntheti...
  type SyntheticItem (line 35) | pub enum SyntheticItem {
    method rels (line 473) | pub fn rels(&self) -> Rels {
  type Synthesizer (line 52) | struct Synthesizer<'a> {
  function synthesize (line 64) | pub fn synthesize(
  function new_wire (line 89) | fn new_wire(&mut self) -> (Tree, Tree) {
  function list (line 94) | fn list<T>(
  function string (line 114) | fn string(&mut self, str: &str) -> Tree {
  function synthesize (line 118) | fn synthesize(&mut self, item: &SyntheticItem) {
  function synthesize_composite_deconstruct (line 139) | fn synthesize_composite_deconstruct(&mut self, len: usize) -> Net {
  function synthesize_composite_reconstruct (line 148) | fn synthesize_composite_reconstruct(&mut self, len: usize) -> Net {
  function synthesize_ident (line 158) | fn synthesize_ident(&mut self, ident: Ident) -> Net {
  function synthesize_identity (line 163) | fn synthesize_identity(&mut self) -> Net {
  function new_stage (line 168) | fn new_stage(&mut self) -> String {
  function synthesize_enum_variant_names (line 173) | fn synthesize_enum_variant_names(&mut self, enum_id: EnumId) -> Net {
  function synthesize_enum_match (line 179) | fn synthesize_enum_match(&mut self, enum_id: EnumId) -> Net {
  function synthesize_enum_reconstruct (line 225) | fn synthesize_enum_reconstruct(&mut self, enum_id: EnumId) -> Net {
  function synthesize_const_alias (line 258) | fn synthesize_const_alias(&self) -> Net {
  function synthesize_fn_from_call (line 262) | fn synthesize_fn_from_call(&mut self, params: usize) -> Net {
  function synthesize_call_from_fn (line 267) | fn synthesize_call_from_fn(&mut self, params: usize) -> Net {
  function _fn_call (line 272) | fn _fn_call(&mut self, params: usize) -> (Tree, Tree) {
  function synthesize_frame (line 299) | fn synthesize_frame(&mut self, path: String, span: Span) -> Net {
  function synthesize_debug_state (line 308) | fn synthesize_debug_state(&mut self) -> Net {
  function synthesize_n32 (line 326) | fn synthesize_n32(&mut self, n32: u32) -> Net {
  function synthesize_string (line 330) | fn synthesize_string(&mut self, string: String) -> Net {
  function enum_ (line 334) | fn enum_(
  function match_enum (line 351) | fn match_enum(
  function variant (line 373) | fn variant(&mut self, variant_id: VariantId, data: Option<Tree>) -> Tree {
  function fn_rel (line 382) | fn fn_rel(&self, id: FnRelId) -> Tree {
  function const_rel (line 391) | fn const_rel(&self, id: ConstRelId) -> Tree {
  function fn_receiver (line 400) | fn fn_receiver(&mut self) -> Tree {
  function const_ (line 413) | fn const_(&mut self, value: Tree) -> Net {

FILE: vine/src/features/annotation.rs
  function resolve_pat_annotation (line 12) | pub(crate) fn resolve_pat_annotation(
  function fmt_pat_annotation (line 24) | pub(crate) fn fmt_pat_annotation(&self, pat: &Pat, ty: &Ty) -> Doc<'src> {

FILE: vine/src/features/assert.rs
  function parse_stmt_assert (line 15) | pub(crate) fn parse_stmt_assert(&mut self) -> Result<StmtKind, Diag> {
  function fmt_stmt_assert (line 25) | pub(crate) fn fmt_stmt_assert(&self, stmt: &AssertStmt) -> Doc<'src> {
  function resolve_stmts_assert (line 36) | pub(crate) fn resolve_stmts_assert(

FILE: vine/src/features/block.rs
  function parse_block (line 20) | pub(crate) fn parse_block(&mut self) -> Result<Block, Diag> {
  function fmt_block (line 29) | pub(crate) fn fmt_block(&self, block: &Block, force_open: bool) -> Doc<'...
  function resolve_block_nil (line 46) | pub(crate) fn resolve_block_nil(&mut self, block: &Block) -> TirExpr {
  function resolve_block_type (line 51) | pub(crate) fn resolve_block_type(&mut self, block: &Block, ty: Type) -> ...
  function resolve_stmts_type (line 58) | pub(crate) fn resolve_stmts_type(&mut self, span: Span, stmts: &[Stmt], ...
  function distill_seq (line 110) | pub(crate) fn distill_seq(

FILE: vine/src/features/builtin.rs
  type Builtin (line 16) | pub enum Builtin {
  function parse_builtin (line 66) | pub(crate) fn parse_builtin(&mut self) -> Result<Builtin, Diag> {
  type Builtins (line 139) | pub struct Builtins {
  function chart_builtin (line 199) | pub(crate) fn chart_builtin(&mut self, item: ChartedItem, builtin: Built...

FILE: vine/src/features/cast.rs
  function fmt_expr_cast (line 12) | pub(crate) fn fmt_expr_cast(&self, expr: &Expr, ty: &Ty, postfix: bool) ...
  function resolve_expr_cast (line 22) | pub(crate) fn resolve_expr_cast(

FILE: vine/src/features/coerce.rs
  function distill_expr_value_coerce_poly (line 16) | pub(crate) fn distill_expr_value_coerce_poly(
  function distill_expr_space_coerce_poly (line 33) | pub(crate) fn distill_expr_space_coerce_poly(
  function distill_expr_place_coerce_poly (line 50) | pub(crate) fn distill_expr_place_coerce_poly(
  function distill_expr_nil_coerce_value (line 65) | pub(crate) fn distill_expr_nil_coerce_value(&mut self, stage: &mut Stage...
  function distill_expr_value_coerce_nil (line 70) | pub(crate) fn distill_expr_value_coerce_nil(
  function coerce_place_value (line 80) | fn coerce_place_value(&mut self, span: Span, stage: &mut Stage, place: (...
  function coerce_place_space (line 84) | fn coerce_place_space(&mut self, span: Span, stage: &mut Stage, place: (...
  function _coerce_place (line 88) | fn _coerce_place(
  function drop (line 142) | pub(crate) fn drop(&mut self, span: Span, stage: &mut Stage, ty: Type, p...
  function drop_space (line 153) | pub(crate) fn drop_space(&mut self, span: Span, stage: &mut Stage, ty: T...

FILE: vine/src/features/composite.rs
  function parse_expr_paren (line 28) | pub(crate) fn parse_expr_paren(&mut self) -> Result<ExprKind, Diag> {
  function parse_pat_paren (line 58) | pub(crate) fn parse_pat_paren(&mut self) -> Result<PatKind, Diag> {
  function parse_ty_paren (line 74) | pub(crate) fn parse_ty_paren(&mut self) -> Result<TyKind, Diag> {
  function _parse_expr_tuple_field (line 90) | pub(crate) fn _parse_expr_tuple_field(&mut self, lhs: Expr) -> Result<Ex...
  function parse_expr_object (line 97) | pub(crate) fn parse_expr_object(&mut self) -> Result<ExprKind, Diag> {
  function parse_pat_object (line 109) | pub(crate) fn parse_pat_object(&mut self) -> Result<PatKind, Diag> {
  function parse_ty_object (line 136) | pub(crate) fn parse_ty_object(&mut self) -> Result<TyKind, Diag> {
  function parse_key (line 145) | fn parse_key(&mut self) -> Result<Key, Diag> {
  function fmt_expr_tuple (line 154) | pub(crate) fn fmt_expr_tuple(&self, t: &[Expr]) -> Doc<'src> {
  function fmt_expr_tuple_field (line 158) | pub(crate) fn fmt_expr_tuple_field(&self, expr: &Expr, index: usize) -> ...
  function fmt_pat_tuple (line 162) | pub(crate) fn fmt_pat_tuple(&self, t: &[Pat]) -> Doc<'src> {
  function fmt_ty_tuple (line 166) | pub(crate) fn fmt_ty_tuple(&self, elements: &[Ty]) -> Doc<'src> {
  function fmt_expr_object (line 170) | pub(crate) fn fmt_expr_object(&self, entries: &[(Key, Expr)]) -> Doc<'sr...
  function fmt_expr_object_field (line 182) | pub(crate) fn fmt_expr_object_field(&self, expr: &Expr, key: &Key) -> Do...
  function fmt_pat_object (line 186) | pub(crate) fn fmt_pat_object(&self, entries: &[(Key, Pat)]) -> Doc<'src> {
  function fmt_ty_object (line 216) | pub(crate) fn fmt_ty_object(&self, entries: &[(Key, Ty)]) -> Doc<'src> {
  function resolve_expr_tuple (line 224) | pub(crate) fn resolve_expr_tuple(
  function resolve_pat_tuple (line 234) | pub(crate) fn resolve_pat_tuple(&mut self, span: Span, elements: &[Pat])...
  function resolve_pat_sig_tuple (line 240) | pub(crate) fn resolve_pat_sig_tuple(&mut self, elements: &[Pat], inferen...
  function resolve_ty_tuple (line 246) | pub(crate) fn resolve_ty_tuple(&mut self, tys: &[Ty], inference: bool) -...
  function resolve_expr_object (line 251) | pub(crate) fn resolve_expr_object(
  function resolve_pat_object (line 262) | pub(crate) fn resolve_pat_object(
  function resolve_pat_sig_object (line 273) | pub(crate) fn resolve_pat_sig_object(&mut self, entries: &[(Key, Pat)], ...
  function resolve_ty_object (line 277) | pub(crate) fn resolve_ty_object(&mut self, entries: &[(Key, Ty)], infere...
  function _build_object (line 281) | fn _build_object<T, U>(
  function _build_object_type (line 298) | fn _build_object_type<T>(
  function resolve_expr_tuple_field (line 318) | pub(crate) fn resolve_expr_tuple_field(
  function _resolve_expr_tuple_field (line 333) | fn _resolve_expr_tuple_field(
  function resolve_expr_object_field (line 356) | pub(crate) fn resolve_expr_object_field(
  function _resolve_expr_object_field (line 373) | fn _resolve_expr_object_field(
  function distill_expr_value_composite (line 415) | pub(crate) fn distill_expr_value_composite(
  function distill_expr_space_composite (line 425) | pub(crate) fn distill_expr_space_composite(
  function distill_expr_place_composite (line 435) | pub(crate) fn distill_expr_place_composite(
  function distill_expr_poly_composite (line 445) | pub(crate) fn distill_expr_poly_composite(
  function distill_pat_value_composite (line 494) | pub(crate) fn distill_pat_value_composite(
  function distill_pat_space_composite (line 504) | pub(crate) fn distill_pat_space_composite(
  function distill_pat_place_composite (line 514) | pub(crate) fn distill_pat_place_composite(
  function distill_expr_poly_field (line 531) | pub(crate) fn distill_expr_poly_field(
  function match_composite (line 573) | pub(crate) fn match_composite<'p>(
  function emit_composite (line 604) | pub(crate) fn emit_composite(&mut self, port: &Port, tuple: &[Port]) {
  function find_auto_impls_tuple (line 611) | pub(crate) fn find_auto_impls_tuple(
  function find_auto_impls_object (line 641) | pub(crate) fn find_auto_impls_object(

FILE: vine/src/features/condition.rs
  function fmt_expr_bool (line 16) | pub(crate) fn fmt_expr_bool(&self, bool: bool) -> Doc<'src> {
  function fmt_expr_not (line 20) | pub(crate) fn fmt_expr_not(&self, expr: &Expr) -> Doc<'src> {
  function fmt_expr_is (line 24) | pub(crate) fn fmt_expr_is(&self, expr: &Expr, pat: &Pat) -> Doc<'src> {
  function fmt_expr_logical_op (line 28) | pub(crate) fn fmt_expr_logical_op(&self, op: &LogicalOp, lhs: &Expr, rhs...
  function resolve_expr_not (line 42) | pub(crate) fn resolve_expr_not(&mut self, span: Span, inner: &Expr) -> R...
  function resolve_cond (line 55) | pub(crate) fn resolve_cond(&mut self, cond: &Expr) -> TirExpr {
  function resolve_scoped_cond (line 62) | pub(crate) fn resolve_scoped_cond(&mut self, cond: &Expr) -> TirExpr {
  function _resolve_scoped_cond (line 72) | pub(crate) fn _resolve_scoped_cond(&mut self, cond: &Expr) -> Result<Tir...
  function distill_cond_bool (line 112) | pub(crate) fn distill_cond_bool(
  function distill_cond (line 155) | pub(crate) fn distill_cond(
  function swap (line 222) | fn swap<T>((a, b): (T, T)) -> (T, T) {
  function swap_if (line 226) | fn swap_if<T>(bool: bool, (a, b): (T, T)) -> (T, T) {

FILE: vine/src/features/const_.rs
  function parse_const_item (line 30) | pub(crate) fn parse_const_item(&mut self) -> Result<(Span, ItemKind), Di...
  function fmt_const_item (line 44) | pub(crate) fn fmt_const_item(&self, c: &ConstItem) -> Doc<'src> {
  function chart_const (line 61) | pub(crate) fn chart_const(
  function resolve_const_sig (line 89) | pub(crate) fn resolve_const_sig(&mut self, const_id: ConcreteConstId) {
  function resolve_const_def (line 106) | pub(crate) fn resolve_const_def(&mut self, const_id: ConcreteConstId) {
  function resolve_config (line 128) | fn resolve_config(&mut self, span: Span, const_id: ConcreteConstId, name...
  function resolve_expr_path_const (line 171) | pub(crate) fn resolve_expr_path_const(
  function distill_expr_value_const (line 189) | pub(crate) fn distill_expr_value_const(
  function emit_const (line 203) | pub(crate) fn emit_const(&mut self, span: &Span, rel: &ConstRelId, out: ...

FILE: vine/src/features/debug.rs
  function tap_debug (line 14) | pub(crate) fn tap_debug(&mut self) -> Tree {
  function tap_debug_call (line 20) | pub(crate) fn tap_debug_call(&mut self, span: Span) -> Tree {
  function with_debug (line 62) | pub fn with_debug(&mut self, inner: Tree) -> Tree {
  function main_net_debug (line 78) | pub(crate) fn main_net_debug(main: Tree) -> Net {

FILE: vine/src/features/do_.rs
  function parse_expr_do (line 20) | pub(crate) fn parse_expr_do(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_do (line 30) | pub(crate) fn fmt_expr_do(&self, label: Label, ty: &Option<Ty>, body: &B...
  function resolve_expr_do (line 42) | pub(crate) fn resolve_expr_do(
  function distill_do (line 62) | pub(crate) fn distill_do(

FILE: vine/src/features/enum_.rs
  function parse_enum_item (line 34) | pub(crate) fn parse_enum_item(&mut self) -> Result<(Span, ItemKind), Dia...
  function parse_variant (line 46) | fn parse_variant(&mut self) -> Result<Variant, Diag> {
  function fmt_enum_item (line 54) | pub(crate) fn fmt_enum_item(&self, e: &EnumItem) -> Doc<'src> {
  function chart_enum (line 78) | pub(crate) fn chart_enum(
  function resolve_enum_sig (line 108) | pub(crate) fn resolve_enum_sig(&mut self, enum_id: EnumId) {
  function resolve_expr_path_enum (line 126) | pub(crate) fn resolve_expr_path_enum(
  function resolve_pat_path_enum (line 159) | pub(crate) fn resolve_pat_path_enum(
  function resolve_pat_sig_path_enum (line 189) | pub(crate) fn resolve_pat_sig_path_enum(&mut self, path: &Path, enum_id:...
  function resolve_ty_path_enum (line 194) | pub(crate) fn resolve_ty_path_enum(
  function distill_expr_value_enum (line 207) | pub(crate) fn distill_expr_value_enum(
  function match_enum (line 224) | pub(crate) fn match_enum<'p>(
  function emit_enum (line 271) | pub(crate) fn emit_enum(
  function find_auto_impls_enum (line 300) | pub(crate) fn find_auto_impls_enum(

FILE: vine/src/features/flex.rs
  function find_auto_impls_fork (line 10) | pub(crate) fn find_auto_impls_fork(
  function find_auto_impls_drop (line 29) | pub(crate) fn find_auto_impls_drop(

FILE: vine/src/features/fn_.rs
  function parse_fn_item (line 33) | pub(crate) fn parse_fn_item(&mut self) -> Result<(Span, ItemKind), Diag> {
  function parse_expr_fn (line 45) | pub(crate) fn parse_expr_fn(&mut self) -> Result<ExprKind, Diag> {
  function parse_stmt_return (line 54) | pub(crate) fn parse_stmt_return(&mut self) -> Result<StmtKind, Diag> {
  function _parse_stmt_let_fn (line 60) | pub(crate) fn _parse_stmt_let_fn(&mut self) -> Result<StmtKind, Diag> {
  function fmt_fn_item (line 73) | pub(crate) fn fmt_fn_item(&self, f: &FnItem) -> Doc<'src> {
  function fmt_stmt_let_fn (line 89) | pub(crate) fn fmt_stmt_let_fn(&self, d: &LetFnStmt) -> Doc<'src> {
  function fmt_expr_fn (line 102) | pub(crate) fn fmt_expr_fn(
  function fmt_expr_call (line 120) | pub(crate) fn fmt_expr_call(&self, func: &Expr, args: &[Expr]) -> Doc<'s...
  function fmt_stmt_return (line 124) | pub(crate) fn fmt_stmt_return(&self, expr: &Option<Expr>) -> Doc<'src> {
  function fmt_return_ty (line 131) | fn fmt_return_ty(&self, r: Option<&Ty>) -> Doc<'src> {
  function chart_fn (line 140) | pub(crate) fn chart_fn(
  function resolve_fn_sig (line 170) | pub(crate) fn resolve_fn_sig(&mut self, fn_id: ConcreteFnId) {
  function _resolve_fn_sig (line 189) | pub(crate) fn _resolve_fn_sig(&mut self, params: &[Pat], ret: &Option<Ty...
  function resolve_fn_def (line 195) | pub(crate) fn resolve_fn_def(&mut self, fn_id: ConcreteFnId) {
  function resolve_expr_fn (line 209) | pub(crate) fn resolve_expr_fn(
  function resolve_stmts_let_fn_group (line 221) | pub(crate) fn resolve_stmts_let_fn_group<'s>(&mut self, mut stmts: &'s [...
  function resolve_closure (line 258) | pub(crate) fn resolve_closure(
  function resolve_expr_path_fn (line 288) | pub(crate) fn resolve_expr_path_fn(
  function resolve_ty_fn (line 329) | pub(crate) fn resolve_ty_fn(&mut self, path: &Path) -> Type {
  function resolve_trait_fn (line 336) | pub(crate) fn resolve_trait_fn(
  function resolve_impl_fn (line 355) | pub(crate) fn resolve_impl_fn(&mut self, span: Span, path: &Path, ty: &I...
  function resolve_expr_call (line 383) | pub(crate) fn resolve_expr_call(
  function _resolve_expr_call (line 393) | pub(crate) fn _resolve_expr_call(
  function resolve_expr_return (line 412) | pub(crate) fn resolve_expr_return(
  function param_name (line 435) | pub(crate) fn param_name(&self, param: &Pat) -> Option<Ident> {
  function distill_closures (line 454) | pub(crate) fn distill_closures(&mut self, fragment: &Fragment) {
  function distill_closure (line 463) | fn distill_closure(&mut self, id: ClosureId, closure: &TirClosure) {
  function distill_expr_value_fn (line 507) | pub(crate) fn distill_expr_value_fn(&mut self, ty: Type) -> Port {
  function distill_expr_value_closure (line 511) | pub(crate) fn distill_expr_value_closure(
  function distill_expr_value_call (line 524) | pub(crate) fn distill_expr_value_call(
  function distill_return (line 540) | pub(crate) fn distill_return(&mut self, stage: &mut Stage, span: Span, v...
  function emit_call (line 553) | pub(crate) fn emit_call(
  function find_auto_impls_fn (line 578) | pub(crate) fn find_auto_impls_fn(

FILE: vine/src/features/for_.rs
  function parse_expr_for (line 24) | pub(crate) fn parse_expr_for(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_for (line 38) | pub(crate) fn fmt_expr_for(
  function resolve_expr_for (line 66) | pub(crate) fn resolve_expr_for(
  function distill_for (line 116) | pub(crate) fn distill_for(

FILE: vine/src/features/generics.rs
  function parse_generic_params (line 21) | pub(crate) fn parse_generic_params(&mut self) -> Result<GenericParams, D...
  function parse_type_param (line 25) | pub(crate) fn parse_type_param(&mut self) -> Result<TypeParam, Diag> {
  function parse_impl_param (line 33) | fn parse_impl_param(&mut self) -> Result<ImplParam, Diag> {
  function parse_generic_args (line 50) | pub(crate) fn parse_generic_args(&mut self) -> Result<GenericArgs, Diag> {
  function parse_generics (line 54) | fn parse_generics<T, I>(
  function parse_generics_section (line 74) | fn parse_generics_section<E>(
  function fmt_generic_params (line 93) | pub(crate) fn fmt_generic_params(&self, generics: &GenericParams) -> Doc...
  function fmt_generic_args (line 97) | pub(crate) fn fmt_generic_args(&self, generics: &GenericArgs) -> Doc<'sr...
  function fmt_type_param (line 101) | pub(crate) fn fmt_type_param(&self, param: &TypeParam) -> Doc<'src> {
  function fmt_impl_param (line 105) | fn fmt_impl_param(&self, param: &ImplParam) -> Doc<'src> {
  function fmt_generics (line 112) | pub(crate) fn fmt_generics<T, I>(
  function fmt_generics_section (line 147) | fn fmt_generics_section<E>(
  function chart_generics (line 166) | pub(crate) fn chart_generics(
  function resolve_type_params (line 184) | pub(crate) fn resolve_type_params(&mut self, generics_id: GenericsId) {
  function resolve_impl_params (line 206) | pub(crate) fn resolve_impl_params(&mut self, generics_id: GenericsId) {
  function resolve_generics (line 278) | pub fn resolve_generics(
  function _resolve_generics (line 287) | pub(crate) fn _resolve_generics(
  function show_generics (line 363) | pub(crate) fn show_generics(&self, generics: GenericsId, impl_params: bo...

FILE: vine/src/features/hole.rs
  function parse_expr_hole (line 17) | pub(crate) fn parse_expr_hole(&mut self) -> Result<ExprKind, Diag> {
  function resolve_expr_hole (line 28) | pub(crate) fn resolve_expr_hole(&mut self, span: Span, ty: Option<&Ty>) ...
  function resolve_pat_hole (line 33) | pub(crate) fn resolve_pat_hole(&mut self, span: Span) -> Result<TirPat, ...
  function resolve_ty_hole (line 37) | pub(crate) fn resolve_ty_hole(&mut self, span: Span, inference: bool) ->...
  function distill_expr_value_hole (line 47) | pub(crate) fn distill_expr_value_hole(
  function distill_expr_space_hole (line 63) | pub(crate) fn distill_expr_space_hole(
  function distill_expr_place_hole (line 72) | pub(crate) fn distill_expr_place_hole(
  function distill_pat_value_hole (line 81) | pub(crate) fn distill_pat_value_hole(&mut self, stage: &mut Stage, span:...
  function distill_pat_space_hole (line 85) | pub(crate) fn distill_pat_space_hole(&mut self, stage: &mut Stage, span:...
  function distill_pat_place_hole (line 89) | pub(crate) fn distill_pat_place_hole(
  function fmt_expr_hole (line 101) | pub(crate) fn fmt_expr_hole(&self, ty: &Option<Ty>) -> Doc<'src> {

FILE: vine/src/features/if_.rs
  function parse_expr_if (line 20) | pub(crate) fn parse_expr_if(&mut self) -> Result<ExprKind, Diag> {
  function parse_ty_if (line 36) | pub(crate) fn parse_ty_if(&mut self) -> Result<TyKind, Diag> {
  function fmt_expr_if (line 54) | pub(crate) fn fmt_expr_if(
  function fmt_expr_if_const (line 74) | pub(crate) fn fmt_expr_if_const(
  function fmt_ty_if_const (line 92) | pub(crate) fn fmt_ty_if_const(&self, cond: &Path, then: &Ty, else_: &Opt...
  function resolve_expr_if (line 108) | pub(crate) fn resolve_expr_if(
  function resolve_expr_if_const (line 129) | pub(crate) fn resolve_expr_if_const(
  function resolve_ty_if_const (line 170) | pub(crate) fn resolve_ty_if_const(
  function distill_if (line 204) | pub(crate) fn distill_if(
  function find_auto_impls_if_const (line 236) | pub(crate) fn find_auto_impls_if_const(

FILE: vine/src/features/impl_.rs
  function parse_impl_item (line 30) | pub(crate) fn parse_impl_item(&mut self) -> Result<(Span, ItemKind), Dia...
  function fmt_impl_item (line 53) | pub(crate) fn fmt_impl_item(&self, i: &ImplItem) -> Doc<'src> {
  function chart_impl (line 76) | pub(crate) fn chart_impl(
  function chart_impl_fn (line 144) | fn chart_impl_fn(
  function chart_impl_const (line 183) | fn chart_impl_const(
  function chart_flex_impls (line 220) | pub fn chart_flex_impls(
  function chart_derive_impls (line 237) | pub fn chart_derive_impls(
  function chart_derive_impl (line 250) | fn chart_derive_impl(
  function resolve_impl_sig (line 283) | pub(crate) fn resolve_impl_sig(&mut self, impl_id: ImplId) {
  function resolve_derive_kind (line 323) | pub(crate) fn resolve_derive_kind(&mut self, kind: &DeriveKind) -> Resul...
  function resolve_derive_impl_ty (line 350) | fn resolve_derive_impl_ty(&mut self, kind: &DeriveKind, ty: DefTypeKind)...
  function resolve_impl_def (line 375) | pub(crate) fn resolve_impl_def(&mut self, impl_id: ImplId) {
  function resolve_impl_become (line 420) | pub(crate) fn resolve_impl_become(&mut self, impl_id: ImplId) -> Become {
  function _resolve_impl_become (line 438) | fn _resolve_impl_become(
  function resolve_tir_impl_become (line 479) | fn resolve_tir_impl_become(
  function resolve_impl_subitem_fn (line 497) | fn resolve_impl_subitem_fn(
  function resolve_impl_subitem_const (line 528) | fn resolve_impl_subitem_const(
  function resolve_impl_subitem_generics (line 566) | fn resolve_impl_subitem_generics(
  function resolve_impl_path_impl (line 624) | pub(crate) fn resolve_impl_path_impl(

FILE: vine/src/features/import.rs
  function parse_use_item (line 25) | pub(crate) fn parse_use_item(&mut self) -> Result<(Span, ItemKind), Diag> {
  function parse_use_tree (line 54) | fn parse_use_tree(&mut self, map: &mut BTreeMap<Ident, UseTree>) -> Resu...
  function parse_use_tree_alias (line 78) | fn parse_use_tree_alias(&mut self, name: Ident, tree: &mut UseTree) -> R...
  function fmt_use_item (line 94) | pub(crate) fn fmt_use_item(&self, u: &UseItem) -> Doc<'src> {
  function fmt_use_tree (line 109) | pub(crate) fn fmt_use_tree(&self, name: Ident, tree: &UseTree) -> Doc<'s...
  function chart_use (line 140) | pub(crate) fn chart_use(&mut self, parent: DefId, vis: VisId, use_item: ...
  function chart_use_tree (line 150) | pub(crate) fn chart_use_tree(
  function resolve_import (line 182) | pub(crate) fn resolve_import(&mut self, import_id: ImportId) -> Result<D...
  function _resolve_import (line 203) | fn _resolve_import(&mut self, import: ImportDef) -> Result<DefId, ErrorG...

FILE: vine/src/features/index.rs
  function fmt_expr_index (line 19) | pub(crate) fn fmt_expr_index(&self, expr: &Expr, index: &Expr) -> Doc<'s...
  function resolve_expr_index (line 25) | pub(crate) fn resolve_expr_index(
  function distill_expr_value_index (line 46) | pub(crate) fn distill_expr_value_index(
  function distill_expr_space_index (line 74) | pub(crate) fn distill_expr_space_index(
  function distill_expr_place_index (line 103) | pub(crate) fn distill_expr_place_index(
  function distill_expr_poly_index (line 135) | pub(crate) fn distill_expr_poly_index(

FILE: vine/src/features/inline_ivy.rs
  function parse_inline_ivy (line 27) | pub(crate) fn parse_inline_ivy(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_inline_ivy (line 56) | pub(crate) fn fmt_expr_inline_ivy(
  function resolve_inline_ivy (line 80) | pub(crate) fn resolve_inline_ivy(
  function distill_expr_value_inline_ivy (line 97) | pub(crate) fn distill_expr_value_inline_ivy(
  function emit_inline_ivy (line 125) | pub(crate) fn emit_inline_ivy(&mut self, binds: &Vec<(String, Port)>, ou...

FILE: vine/src/features/inverse.rs
  function fmt_expr_inverse (line 17) | pub(crate) fn fmt_expr_inverse(&self, expr: &Expr, postfix: bool) -> Doc...
  function fmt_pat_inverse (line 25) | pub(crate) fn fmt_pat_inverse(&self, pat: &Pat) -> Doc<'src> {
  function fmt_ty_inverse (line 29) | pub(crate) fn fmt_ty_inverse(&self, ty: &Ty) -> Doc<'src> {
  function resolve_expr_inverse (line 35) | pub(crate) fn resolve_expr_inverse(&mut self, span: Span, inner: &Expr) ...
  function resolve_pat_inverse (line 40) | pub(crate) fn resolve_pat_inverse(&mut self, span: Span, inner: &Pat) ->...
  function resolve_pat_sig_inverse (line 45) | pub(crate) fn resolve_pat_sig_inverse(&mut self, inner: &Pat, inference:...
  function resolve_ty_inverse (line 50) | pub(crate) fn resolve_ty_inverse(&mut self, inner: &Ty, inference: bool)...
  function distill_expr_value_inverse (line 57) | pub(crate) fn distill_expr_value_inverse(&mut self, stage: &mut Stage, i...
  function distill_expr_space_inverse (line 61) | pub(crate) fn distill_expr_space_inverse(&mut self, stage: &mut Stage, i...
  function distill_expr_place_inverse (line 65) | pub(crate) fn distill_expr_place_inverse(
  function distill_expr_poly_inverse (line 74) | pub(crate) fn distill_expr_poly_inverse(&mut self, stage: &mut Stage, in...
  function distill_pat_value_inverse (line 83) | pub(crate) fn distill_pat_value_inverse(&mut self, stage: &mut Stage, in...
  function distill_pat_space_inverse (line 87) | pub(crate) fn distill_pat_space_inverse(&mut self, stage: &mut Stage, in...
  function distill_pat_place_inverse (line 91) | pub(crate) fn distill_pat_place_inverse(

FILE: vine/src/features/labels.rs
  function parse_label (line 20) | pub(crate) fn parse_label(&mut self) -> Result<Label, Diag> {
  function parse_target (line 24) | pub(crate) fn parse_target(&mut self) -> Result<Target, Diag> {
  function parse_stmt_break (line 44) | pub(crate) fn parse_stmt_break(&mut self) -> Result<StmtKind, Diag> {
  function parse_stmt_continue (line 51) | pub(crate) fn parse_stmt_continue(&mut self) -> Result<StmtKind, Diag> {
  function fmt_label (line 59) | pub(crate) fn fmt_label(&self, label: Label) -> Doc<'src> {
  function fmt_target (line 63) | pub(crate) fn fmt_target(&self, target: Target) -> Doc<'src> {
  function fmt_stmt_break (line 75) | pub(crate) fn fmt_stmt_break(&self, target: Target, expr: &Option<Expr>)...
  function fmt_stmt_continue (line 88) | pub(crate) fn fmt_stmt_continue(&self, target: Target) -> Doc<'src> {
  function bind_target (line 94) | pub(crate) fn bind_target<T>(
  function resolve_expr_break (line 112) | pub(crate) fn resolve_expr_break(
  function resolve_expr_continue (line 144) | pub(crate) fn resolve_expr_continue(
  function distill_break (line 159) | pub(crate) fn distill_break(
  function distill_continue (line 177) | pub(crate) fn distill_continue(&mut self, stage: &mut Stage, label: Targ...

FILE: vine/src/features/let_.rs
  function parse_stmt_let (line 16) | pub(crate) fn parse_stmt_let(&mut self) -> Result<StmtKind, Diag> {
  function fmt_stmt_let (line 36) | pub(crate) fn fmt_stmt_let(&self, stmt: &LetStmt) -> Doc<'src> {
  function resolve_stmts_let (line 52) | pub(crate) fn resolve_stmts_let(
  function distill_let (line 73) | pub(crate) fn distill_let(

FILE: vine/src/features/list.rs
  function parse_expr_list (line 22) | pub(crate) fn parse_expr_list(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_list (line 29) | pub(crate) fn fmt_expr_list(&self, elements: &[Expr]) -> Doc<'src> {
  function resolve_expr_list (line 35) | pub(crate) fn resolve_expr_list(
  function distill_expr_value_list (line 55) | pub(crate) fn distill_expr_value_list(
  function emit_list (line 67) | pub(crate) fn emit_list(&mut self, port: &Port, list: &[Port]) {
  function build_list (line 73) | pub(crate) fn build_list<T>(

FILE: vine/src/features/local.rs
  function distill_expr_value_local (line 16) | pub(crate) fn distill_expr_value_local(
  function distill_expr_space_local (line 26) | pub(crate) fn distill_expr_space_local(
  function distill_expr_place_local (line 36) | pub(crate) fn distill_expr_place_local(
  function distill_pat_value_local (line 46) | pub(crate) fn distill_pat_value_local(
  function distill_pat_space_local (line 57) | pub(crate) fn distill_pat_space_local(
  function distill_pat_place_local (line 68) | pub(crate) fn distill_pat_place_local(
  function distill_pat_uninit_local (line 80) | pub(crate) fn distill_pat_uninit_local(&mut self, stage: &mut Stage, spa...
  function distill_pat_loop_local (line 85) | pub(crate) fn distill_pat_loop_local(&mut self, stage: &mut Stage, local...
  type LocalEmissionState (line 91) | pub(crate) struct LocalEmissionState {
    method read (line 212) | fn read(&mut self, tree: Tree) {
    method read_barrier (line 219) | fn read_barrier(&mut self, tree: Tree) {
    method write (line 224) | fn write(&mut self, tree: Tree) {
    method barrier_write (line 231) | fn barrier_write(&mut self, tree: Tree) {
    method read_write (line 236) | fn read_write(&mut self, a: Tree, b: Tree) {
    method barrier (line 241) | fn barrier(&mut self) {
  function local (line 99) | fn local(&mut self, local: Local) -> &mut LocalEmissionState {
  function emit_invocation (line 108) | pub(crate) fn emit_invocation(&mut self, local: &Local, invocation: &Inv...
  function emit_compound_invocation (line 135) | pub(crate) fn emit_compound_invocation(
  function finish_local (line 158) | pub(crate) fn finish_local(&mut self, local: &VirLocal, mut state: Local...

FILE: vine/src/features/loop_.rs
  function parse_expr_loop (line 21) | pub(crate) fn parse_expr_loop(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_loop (line 31) | pub(crate) fn fmt_expr_loop(&self, label: Label, ty: &Option<Ty>, body: ...
  function resolve_expr_loop (line 43) | pub(crate) fn resolve_expr_loop(
  function distill_loop (line 63) | pub(crate) fn distill_loop(

FILE: vine/src/features/match_.rs
  function parse_expr_match (line 22) | pub(crate) fn parse_expr_match(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_match (line 36) | pub(crate) fn fmt_expr_match(
  function resolve_match (line 57) | pub(crate) fn resolve_match(
  function distill_match (line 78) | pub(crate) fn distill_match(

FILE: vine/src/features/method.rs
  function fmt_expr_method (line 15) | pub(crate) fn fmt_expr_method(
  function resolve_method (line 33) | pub(crate) fn resolve_method(
  function find_method (line 95) | fn find_method(

FILE: vine/src/features/mod_.rs
  function parse_mod_item (line 18) | pub(crate) fn parse_mod_item(&mut self) -> Result<(Span, ItemKind), Diag> {
  function fmt_mod_item (line 41) | pub(crate) fn fmt_mod_item(&self, m: &ModItem) -> Doc<'src> {
  function chart_mod (line 59) | pub(crate) fn chart_mod(

FILE: vine/src/features/numeric.rs
  function parse_expr_numeric (line 19) | pub(crate) fn parse_expr_numeric(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_nat (line 43) | pub(crate) fn fmt_expr_nat(&self, lit_span: Span, ty: &Ty) -> Doc<'src> {
  function fmt_expr_float (line 47) | pub(crate) fn fmt_expr_float(&self, lit_span: Span, ty: &Ty) -> Doc<'src> {
  function resolve_expr_n32 (line 53) | pub(crate) fn resolve_expr_n32(&mut self, span: Span, n: u32) -> Result<...
  function resolve_expr_f32 (line 58) | pub(crate) fn resolve_expr_f32(&mut self, span: Span, n: f32) -> Result<...
  function resolve_expr_float (line 63) | pub(crate) fn resolve_expr_float(
  function resolve_expr_nat (line 85) | pub(crate) fn resolve_expr_nat(&mut self, span: Span, n: &Nat, ty: &Ty) ...
  function distill_expr_value_n32 (line 105) | pub(crate) fn distill_expr_value_n32(&mut self, ty: Type, n: u32) -> Port {
  function distill_expr_value_f32 (line 109) | pub(crate) fn distill_expr_value_f32(&mut self, ty: Type, f: f32) -> Port {
  function distill_expr_value_f64 (line 113) | pub(crate) fn distill_expr_value_f64(&mut self, ty: Type, f: f64) -> Port {
  function distill_expr_value_nat (line 117) | pub(crate) fn distill_expr_value_nat(&mut self, ty: Type, n: &Nat) -> Po...
  function emit_nat (line 123) | pub(crate) fn emit_nat(&mut self, n: &Nat) -> Tree {

FILE: vine/src/features/ops.rs
  function fmt_expr_assign (line 15) | pub(crate) fn fmt_expr_assign(&self, inverted: bool, space: &Expr, value...
  function fmt_expr_sign (line 23) | pub(crate) fn fmt_expr_sign(&self, sign: Sign, expr: &Expr) -> Doc<'src> {
  function fmt_expr_binary_op (line 33) | pub(crate) fn fmt_expr_binary_op(&self, op: &BinaryOp, lhs: &Expr, rhs: ...
  function fmt_expr_binary_op_assign (line 37) | pub(crate) fn fmt_expr_binary_op_assign(
  function fmt_expr_comparison_op (line 46) | pub(crate) fn fmt_expr_comparison_op(
  function resolve_expr_assign (line 58) | pub(crate) fn resolve_expr_assign(
  function resolve_expr_sign (line 70) | pub(crate) fn resolve_expr_sign(
  function resolve_expr_binary_op (line 85) | pub(crate) fn resolve_expr_binary_op(
  function resolve_expr_binary_op_assign (line 100) | pub(crate) fn resolve_expr_binary_op_assign(
  function resolve_expr_comparison_op (line 114) | pub(crate) fn resolve_expr_comparison_op(
  function distill_expr_nil_assign (line 151) | pub(crate) fn distill_expr_nil_assign(
  function distill_expr_nil_call_assign (line 169) | pub(crate) fn distill_expr_nil_call_assign(
  function distill_expr_value_call_compare (line 182) | pub(crate) fn distill_expr_value_call_compare(

FILE: vine/src/features/path.rs
  function parse_path (line 23) | pub(crate) fn parse_path(&mut self) -> Result<Path, Diag> {
  function parse_expr_path (line 32) | pub(crate) fn parse_expr_path(&mut self) -> Result<ExprKind, Diag> {
  function parse_pat_path (line 38) | pub(crate) fn parse_pat_path(&mut self) -> Result<PatKind, Diag> {
  function fmt_path (line 46) | pub(crate) fn fmt_path(&self, path: &Path) -> Doc<'src> {
  function fmt_expr_path (line 65) | pub(crate) fn fmt_expr_path(&self, path: &Path, args: &Option<Vec<Expr>>...
  function fmt_pat_path (line 74) | pub(crate) fn fmt_pat_path(&self, path: &Path, args: &Option<Vec<Pat>>) ...
  function resolve_path (line 85) | pub fn resolve_path<T>(
  function resolve_path_impl (line 113) | pub fn resolve_path_impl(
  function _resolve_path (line 144) | fn _resolve_path(&mut self, source: DefId, path: &Path) -> Result<DefId,...
  function resolve_absolute (line 158) | pub(crate) fn resolve_absolute(&mut self, span: Span, ident: Ident) -> R...
  function resolve_local (line 165) | pub(crate) fn resolve_local(
  function resolve_segment (line 190) | pub(crate) fn resolve_segment(
  function _resolve_segment (line 201) | fn _resolve_segment(
  function resolve_expr_path (line 235) | pub(crate) fn resolve_expr_path(
  function resolve_pat_path (line 276) | pub(crate) fn resolve_pat_path(
  function resolve_pat_sig_path (line 306) | pub(crate) fn resolve_pat_sig_path(&mut self, span: Span, path: &Path, i...
  function resolve_ty_path (line 322) | pub(crate) fn resolve_ty_path(&mut self, path: &Path, inference: bool) -...
  function resolve_impl_path (line 341) | pub(crate) fn resolve_impl_path(&mut self, path: &Path, ty: &ImplType) -...

FILE: vine/src/features/place.rs
  function fmt_expr_place (line 13) | pub(crate) fn fmt_expr_place(&self, v: &Expr, s: &Expr) -> Doc<'src> {
  function resolve_expr_place (line 19) | pub(crate) fn resolve_expr_place(
  function distill_expr_place_place (line 41) | pub(crate) fn distill_expr_place_place(

FILE: vine/src/features/range.rs
  function _parse_expr_range (line 19) | pub(crate) fn _parse_expr_range(&mut self, left_bound: Option<Expr>) -> ...
  function fmt_expr_range_inclusive (line 33) | pub(crate) fn fmt_expr_range_inclusive(&self, start: &Option<Expr>, end:...
  function fmt_expr_range_exclusive (line 43) | pub(crate) fn fmt_expr_range_exclusive(
  function resolve_expr_range (line 61) | pub(crate) fn resolve_expr_range(
  function resolve_range_bound (line 86) | fn resolve_range_bound(

FILE: vine/src/features/reference.rs
  function parse_expr_ref (line 24) | pub(crate) fn parse_expr_ref(&mut self, span: usize) -> Result<ExprKind,...
  function parse_expr_deref (line 35) | pub(crate) fn parse_expr_deref(&mut self, span: usize) -> Result<ExprKin...
  function parse_pat_ref (line 46) | pub(crate) fn parse_pat_ref(&mut self, span: usize) -> Result<PatKind, D...
  function parse_pat_deref (line 57) | pub(crate) fn parse_pat_deref(&mut self, span: usize) -> Result<PatKind,...
  function parse_ty_ref (line 68) | pub(crate) fn parse_ty_ref(&mut self, span: usize) -> Result<TyKind, Dia...
  function fmt_expr_ref (line 81) | pub(crate) fn fmt_expr_ref(&self, expr: &Expr, postfix: bool) -> Doc<'sr...
  function fmt_expr_deref (line 89) | pub(crate) fn fmt_expr_deref(&self, expr: &Expr, postfix: bool) -> Doc<'...
  function fmt_pat_ref (line 97) | pub(crate) fn fmt_pat_ref(&self, pat: &Pat) -> Doc<'src> {
  function fmt_pat_deref (line 101) | pub(crate) fn fmt_pat_deref(&self, pat: &Pat) -> Doc<'src> {
  function fmt_ty_ref (line 105) | pub(crate) fn fmt_ty_ref(&self, ty: &Ty) -> Doc<'src> {
  function resolve_expr_ref (line 111) | pub(crate) fn resolve_expr_ref(&mut self, span: Span, inner: &Expr) -> R...
  function resolve_expr_deref (line 116) | pub(crate) fn resolve_expr_deref(&mut self, span: Span, inner: &Expr) ->...
  function resolve_pat_ref (line 123) | pub(crate) fn resolve_pat_ref(&mut self, span: Span, inner: &Pat) -> Res...
  function resolve_pat_sig_ref (line 128) | pub(crate) fn resolve_pat_sig_ref(&mut self, inner: &Pat, inference: boo...
  function resolve_pat_deref (line 133) | pub(crate) fn resolve_pat_deref(&mut self, span: Span, inner: &Pat) -> R...
  function resolve_ty_ref (line 140) | pub(crate) fn resolve_ty_ref(&mut self, inner: &Ty, inference: bool) -> ...
  function distill_expr_value_ref (line 147) | pub(crate) fn distill_expr_value_ref(
  function distill_expr_place_deref (line 158) | pub(crate) fn distill_expr_place_deref(
  function distill_pat_value_ref (line 172) | pub(crate) fn distill_pat_value_ref(
  function distill_pat_place_ref (line 185) | pub(crate) fn distill_pat_place_ref(
  function distill_pat_place_deref (line 201) | pub(crate) fn distill_pat_place_deref(
  function match_ref (line 217) | pub(crate) fn match_ref<'p>(
  function emit_ref (line 239) | pub(crate) fn emit_ref(&mut self, reference: &Port, value: &Port, space:...

FILE: vine/src/features/string.rs
  function parse_string (line 24) | pub(crate) fn parse_string(&mut self) -> Result<String, Diag> {
  function parse_expr_string (line 36) | pub(crate) fn parse_expr_string(&mut self) -> Result<ExprKind, Diag> {
  function parse_string_segment (line 54) | fn parse_string_segment(&mut self) -> Result<(StringSegment, bool), Diag> {
  function parse_expr_char (line 73) | pub(crate) fn parse_expr_char(&mut self) -> Result<ExprKind, Diag> {
  type StrToken (line 102) | pub enum StrToken {
  type StrLexer (line 111) | pub struct StrLexer<'src> {
  function new (line 117) | fn new(file: FileId, src: &'src str) -> Self {
  function span (line 121) | fn span(&self) -> Span {
  function invalid_escape (line 126) | fn invalid_escape(&self) -> Diag {
  type Token (line 132) | type Token = StrToken;
  type Error (line 133) | type Error = Diag;
  function state (line 135) | fn state(&self) -> &LexerState<'src> {
  function state_mut (line 139) | fn state_mut(&mut self) -> &mut LexerState<'src> {
  function lex (line 143) | fn lex(&mut self) -> Result<Self::Token, Self::Error> {
  function fmt_expr_string (line 194) | pub(crate) fn fmt_expr_string(
  function resolve_expr_char (line 210) | pub(crate) fn resolve_expr_char(&mut self, span: Span, char: char) -> Re...
  function resolve_expr_string (line 215) | pub(crate) fn resolve_expr_string(
  function distill_expr_value_char (line 246) | pub(crate) fn distill_expr_value_char(&mut self, ty: Type, char: char) -...
  function distill_expr_value_string (line 250) | pub(crate) fn distill_expr_value_string(
  function emit_string (line 267) | pub(crate) fn emit_string(&mut self, port: &Port, init: &str, rest: &Vec...

FILE: vine/src/features/struct_.rs
  function parse_struct_item (line 34) | pub(crate) fn parse_struct_item(&mut self) -> Result<(Span, ItemKind), D...
  function fmt_struct_item (line 54) | pub(crate) fn fmt_struct_item(&self, s: &StructItem) -> Doc<'src> {
  function fmt_expr_unwrap (line 87) | pub(crate) fn fmt_expr_unwrap(&self, expr: &Expr) -> Doc<'src> {
  function chart_struct (line 93) | pub(crate) fn chart_struct(
  function resolve_struct_sig (line 124) | pub(crate) fn resolve_struct_sig(&mut self, struct_id: StructId) {
  function resolve_expr_path_struct (line 150) | pub(crate) fn resolve_expr_path_struct(
  function resolve_pat_path_struct (line 180) | pub(crate) fn resolve_pat_path_struct(
  function resolve_pat_sig_path_struct (line 205) | pub(crate) fn resolve_pat_sig_path_struct(&mut self, path: &Path, struct...
  function resolve_ty_path_struct (line 211) | pub(crate) fn resolve_ty_path_struct(
  function resolve_expr_unwrap (line 222) | pub(crate) fn resolve_expr_unwrap(&mut self, span: Span, inner: &Expr) -...
  function get_struct_data (line 237) | pub(crate) fn get_struct_data(
  function distill_expr_value_rewrap (line 258) | pub(crate) fn distill_expr_value_rewrap(
  function distill_expr_space_rewrap (line 271) | pub(crate) fn distill_expr_space_rewrap(
  function distill_expr_place_rewrap (line 284) | pub(crate) fn distill_expr_place_rewrap(
  function distill_expr_poly_rewrap (line 299) | pub(crate) fn distill_expr_poly_rewrap(
  function distill_pat_value_struct (line 328) | pub(crate) fn distill_pat_value_struct(
  function distill_pat_space_struct (line 341) | pub(crate) fn distill_pat_space_struct(
  function distill_pat_place_struct (line 354) | pub(crate) fn distill_pat_place_struct(
  function match_struct (line 371) | pub(crate) fn match_struct<'p>(
  function find_auto_impls_struct (line 396) | pub(crate) fn find_auto_impls_struct(

FILE: vine/src/features/trait_.rs
  function parse_trait_item (line 26) | pub(crate) fn parse_trait_item(&mut self) -> Result<(Span, ItemKind), Di...
  function fmt_trait_item (line 43) | pub(crate) fn fmt_trait_item(&self, t: &TraitItem) -> Doc<'src> {
  function chart_trait (line 57) | pub(crate) fn chart_trait(
  function chart_trait_fn (line 139) | fn chart_trait_fn(
  function chart_trait_const (line 172) | fn chart_trait_const(
  function resolve_trait_sig (line 205) | pub(crate) fn resolve_trait_sig(&mut self, trait_id: TraitId) {

FILE: vine/src/features/try_.rs
  function fmt_expr_try (line 15) | pub(crate) fn fmt_expr_try(&self, expr: &Expr) -> Doc<'src> {
  function resolve_expr_try (line 21) | pub(crate) fn resolve_expr_try(&mut self, span: Span, result: &Expr) -> ...
  function distill_try (line 50) | pub(crate) fn distill_try(

FILE: vine/src/features/type_.rs
  function parse_type_item (line 26) | pub(crate) fn parse_type_item(&mut self) -> Result<(Span, ItemKind), Dia...
  function fmt_type_item (line 38) | pub(crate) fn fmt_type_item(&self, t: &TypeItem) -> Doc<'src> {
  function chart_type (line 53) | pub(crate) fn chart_type(
  function resolve_type_alias (line 81) | pub(crate) fn resolve_type_alias(&mut self, alias_id: TypeAliasId) {
  function resolve_opaque_type (line 117) | pub(crate) fn resolve_opaque_type(&mut self, opaque_id: OpaqueTypeId) {
  function resolve_ty_path_alias (line 124) | pub(crate) fn resolve_ty_path_alias(
  function resolve_ty_path_opaque (line 150) | pub(crate) fn resolve_ty_path_opaque(
  function find_auto_impls_opaque (line 163) | pub(crate) fn find_auto_impls_opaque(

FILE: vine/src/features/union.rs
  function chart_union (line 27) | pub(crate) fn chart_union(
  function resolve_union_sig (line 60) | pub(crate) fn resolve_union_sig(&mut self, union_id: UnionId) {
  function resolve_expr_path_union (line 85) | pub(crate) fn resolve_expr_path_union(
  function resolve_pat_path_union (line 119) | pub(crate) fn resolve_pat_path_union(
  function resolve_pat_sig_path_union (line 148) | pub(crate) fn resolve_pat_sig_path_union(&mut self, path: &Path, union_i...
  function resolve_ty_path_union (line 153) | pub(crate) fn resolve_ty_path_union(
  function distill_pat_value_union (line 166) | pub(crate) fn distill_pat_value_union(
  function distill_pat_space_union (line 179) | pub(crate) fn distill_pat_space_union(
  function distill_pat_place_union (line 192) | pub(crate) fn distill_pat_place_union(
  function emit_union (line 209) | pub(crate) fn emit_union(

FILE: vine/src/features/when.rs
  function parse_expr_when (line 21) | pub(crate) fn parse_expr_when(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_when (line 39) | pub(crate) fn fmt_expr_when(
  function resolve_expr_when (line 64) | pub(crate) fn resolve_expr_when(
  function distill_when (line 108) | pub(crate) fn distill_when(

FILE: vine/src/features/while_.rs
  function parse_expr_while (line 21) | pub(crate) fn parse_expr_while(&mut self) -> Result<ExprKind, Diag> {
  function fmt_expr_while (line 33) | pub(crate) fn fmt_expr_while(
  function resolve_expr_while (line 58) | pub(crate) fn resolve_expr_while(
  function distill_while (line 91) | pub(crate) fn distill_while(

FILE: vine/src/structures/annotations.rs
  type Annotations (line 6) | pub struct Annotations {
    method record_reference (line 19) | pub fn record_reference(&mut self, ref_span: Span, def_span: Span) {
    method record_signature (line 24) | pub fn record_signature(&mut self, span: Span, signature: String) {
    method record_docs (line 28) | pub fn record_docs(&mut self, span: Span, doc: Vec<String>) {
  type Hover (line 13) | pub struct Hover {

FILE: vine/src/structures/ast.rs
  type Item (line 19) | pub struct Item {
  type ItemKind (line 30) | pub enum ItemKind {
  type FnItem (line 45) | pub struct FnItem {
  type ConstItem (line 55) | pub struct ConstItem {
  type TypeItem (line 63) | pub struct TypeItem {
  type StructItem (line 70) | pub struct StructItem {
  type EnumItem (line 80) | pub struct EnumItem {
  type Variant (line 89) | pub struct Variant {
  type ModItem (line 95) | pub struct ModItem {
  type ModKind (line 102) | pub enum ModKind {
  type TraitItem (line 109) | pub struct TraitItem {
  type ImplItem (line 118) | pub struct ImplItem {
  type ImplItemKind (line 127) | pub enum ImplItemKind {
  type UseItem (line 133) | pub struct UseItem {
  type UseTree (line 139) | pub struct UseTree {
    method empty (line 148) | pub fn empty(span: Span) -> Self {
    method prune (line 158) | pub fn prune(&mut self) -> bool {
  type Vis (line 165) | pub enum Vis {
  type Attr (line 172) | pub struct Attr {
  type AttrKind (line 179) | pub enum AttrKind {
  type GenericParams (line 191) | pub type GenericParams = Generics<TypeParam, ImplParam>;
  type GenericArgs (line 192) | pub type GenericArgs = Generics<Ty, Impl>;
  type Generics (line 195) | pub struct Generics<T, I> {
  function empty (line 203) | pub fn empty(span: Span) -> Self {
  type TypeParam (line 209) | pub struct TypeParam {
  type ImplParam (line 216) | pub struct ImplParam {
  type Flex (line 223) | pub enum Flex {
    method fork (line 231) | pub fn fork(self) -> bool {
    method drop (line 235) | pub fn drop(self) -> bool {
    method sigil (line 239) | pub fn sigil(self) -> &'static str {
  type Block (line 250) | pub struct Block {
    method from (line 664) | fn from(err: ErrorGuaranteed) -> Self {
  type Stmt (line 256) | pub struct Stmt {
    method from (line 658) | fn from(err: ErrorGuaranteed) -> Self {
  type StmtKind (line 262) | pub enum StmtKind {
  type LetStmt (line 275) | pub struct LetStmt {
  type LetStmtKind (line 281) | pub enum LetStmtKind {
  type AssertStmt (line 288) | pub struct AssertStmt {
  type LetFnStmt (line 294) | pub struct LetFnStmt {
  type Expr (line 304) | pub struct Expr {
    method from (line 652) | fn from(err: ErrorGuaranteed) -> Self {
  type ExprKind (line 310) | pub enum ExprKind {
    method from (line 634) | fn from(err: ErrorGuaranteed) -> Self {
  type Label (line 361) | pub struct Label(pub Option<Ident>);
  type Target (line 364) | pub enum Target {
  type StringSegment (line 375) | pub struct StringSegment {
  type Sign (line 381) | pub enum Sign {
  type Pat (line 387) | pub struct Pat {
  type PatKind (line 393) | pub enum PatKind {
    method from (line 640) | fn from(err: ErrorGuaranteed) -> Self {
  type Path (line 408) | pub struct Path {
    method as_ident (line 416) | pub fn as_ident(&self) -> Option<Ident> {
    method from (line 607) | fn from(key: Key) -> Self {
  type Ty (line 427) | pub struct Ty {
  type TyKind (line 433) | pub enum TyKind {
    method from (line 646) | fn from(err: ErrorGuaranteed) -> Self {
  type Impl (line 449) | pub struct Impl {
  type ImplKind (line 455) | pub enum ImplKind {
  type Trait (line 464) | pub struct Trait {
  type TraitKind (line 470) | pub enum TraitKind {
  type BinaryOp (line 477) | pub enum BinaryOp {
    method as_str (line 499) | pub fn as_str(&self) -> &'static str {
  method fmt (line 493) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LogicalOp (line 518) | pub enum LogicalOp {
  type ComparisonOp (line 525) | pub enum ComparisonOp {
    method as_str (line 535) | pub fn as_str(&self) -> &'static str {
  type Ident (line 548) | pub struct Ident(pub String);
    method new (line 551) | pub fn new(str: &str) -> Option<Ident> {
  type Key (line 557) | pub struct Key {
  method fmt (line 563) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Span (line 569) | pub struct Span {
    constant NONE (line 588) | pub const NONE: Span = Span { file: FileId(usize::MAX), start: 0, end:...
  method cmp (line 576) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 582) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method fmt (line 592) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 613) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: vine/src/structures/ast/visit.rs
  type VisitMut (line 35) | pub trait VisitMut<'a> {
    method visit_expr (line 36) | fn visit_expr(&mut self, expr: &'a mut Expr) {
    method visit_pat (line 40) | fn visit_pat(&mut self, pat: &'a mut Pat) {
    method visit_type (line 44) | fn visit_type(&mut self, ty: &'a mut Ty) {
    method visit_impl (line 48) | fn visit_impl(&mut self, ty: &'a mut Impl) {
    method visit_trait (line 52) | fn visit_trait(&mut self, trait_: &'a mut Trait) {
    method visit_stmt (line 56) | fn visit_stmt(&mut self, stmt: &'a mut Stmt) {
    method visit_item (line 60) | fn visit_item(&mut self, item: &'a mut Item) {
    method visit_block (line 64) | fn visit_block(&mut self, block: &'a mut Block) {
    method visit_generic_params (line 68) | fn visit_generic_params(&mut self, generics: &'a mut GenericParams) {
    method visit_generic_args (line 72) | fn visit_generic_args(&mut self, generics: &'a mut GenericArgs) {
    method _visit_expr (line 76) | fn _visit_expr(&mut self, expr: &'a mut Expr) {
    method _visit_pat (line 212) | fn _visit_pat(&mut self, pat: &'a mut Pat) {
    method _visit_type (line 241) | fn _visit_type(&mut self, ty: &'a mut Ty) {
    method _visit_impl (line 266) | fn _visit_impl(&mut self, impl_: &'a mut Impl) {
    method _visit_trait (line 274) | fn _visit_trait(&mut self, trait_: &'a mut Trait) {
    method _visit_stmt (line 286) | fn _visit_stmt(&mut self, stmt: &'a mut Stmt) {
    method _visit_item (line 318) | fn _visit_item(&mut self, item: &'a mut Item) {
    method _visit_block (line 363) | fn _visit_block(&mut self, block: &'a mut Block) {
    method _visit_generic_params (line 369) | fn _visit_generic_params(&mut self, generics: &'a mut GenericParams) {
    method _visit_generic_args (line 373) | fn _visit_generic_args(&mut self, generics: &'a mut GenericArgs) {
    method visit (line 378) | fn visit(&mut self, visitee: impl Visitee<'a>) {
  type Visitee (line 383) | pub trait Visitee<'t>: Sized {
    method visit (line 384) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized));
  function visit (line 388) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 394) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 400) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 406) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 412) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 418) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 424) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 430) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 436) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  function visit (line 442) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {
  method visit (line 448) | fn visit(self, visitor: &mut (impl VisitMut<'t> + ?Sized)) {

FILE: vine/src/structures/chart.rs
  type Chart (line 12) | pub struct Chart {
    method visible (line 329) | pub fn visible(&self, vis: VisId, from: DefId) -> bool {
    method fn_is_method (line 338) | pub fn fn_is_method(&self, fn_id: FnId) -> bool {
    method fn_generics (line 345) | pub fn fn_generics(&self, fn_id: FnId) -> GenericsId {
    method fn_is_unsafe (line 352) | pub fn fn_is_unsafe(&self, fn_id: FnId) -> bool {
    method const_generics (line 359) | pub fn const_generics(&self, const_id: ConstId) -> GenericsId {
    method const_is_unsafe (line 366) | pub fn const_is_unsafe(&self, const_id: ConstId) -> bool {
    method fn_span (line 373) | pub fn fn_span(&self, fn_id: FnId) -> Span {
  type Def (line 34) | pub struct Def {
    method fn_id (line 382) | pub fn fn_id(&self) -> Option<Binding<FnId>> {
  type VisId (line 55) | pub enum VisId {
  type Binding (line 61) | pub struct Binding<T> {
  type MemberKind (line 68) | pub enum MemberKind {
  type DefValueKind (line 74) | pub enum DefValueKind {
  type ConstId (line 83) | pub enum ConstId {
  type FnId (line 89) | pub enum FnId {
  type DefTypeKind (line 95) | pub enum DefTypeKind {
  type DefPatternKind (line 104) | pub enum DefPatternKind {
  type DefTraitKind (line 111) | pub enum DefTraitKind {
  type DefImplKind (line 116) | pub enum DefImplKind {
  type ImportDef (line 122) | pub struct ImportDef {
  type ImportParent (line 130) | pub enum ImportParent {
  type GenericsDef (line 138) | pub struct GenericsDef {
  type GenericsKind (line 147) | pub enum GenericsKind {
  type DeriveKind (line 155) | pub enum DeriveKind {
  type ConcreteConstDef (line 163) | pub struct ConcreteConstDef {
  type ConcreteFnDef (line 176) | pub struct ConcreteFnDef {
  type OpaqueTypeDef (line 191) | pub struct OpaqueTypeDef {
  type TypeAliasDef (line 200) | pub struct TypeAliasDef {
  type StructDef (line 210) | pub struct StructDef {
  type EnumDef (line 222) | pub struct EnumDef {
  type EnumVariant (line 232) | pub struct EnumVariant {
  type UnionDef (line 241) | pub struct UnionDef {
  type UnionVariant (line 251) | pub struct UnionVariant {
  type TraitDef (line 260) | pub struct TraitDef {
  type TraitConst (line 273) | pub struct TraitConst {
  type TraitFn (line 283) | pub struct TraitFn {
  type ImplDef (line 295) | pub struct ImplDef {
  type ImplDefKind (line 309) | pub enum ImplDefKind {
  type ImplSubitem (line 316) | pub struct ImplSubitem {
  type ImplSubitemKind (line 323) | pub enum ImplSubitemKind {
  constant NONE (line 393) | pub const NONE: Self = Self(usize::MAX);
  constant NONE (line 397) | pub const NONE: Self = Self(0);

FILE: vine/src/structures/checkpoint.rs
  type Checkpoint (line 24) | pub struct Checkpoint {
  method checkpoint (line 46) | pub fn checkpoint(&self) -> Checkpoint {
  method revert (line 69) | pub fn revert(&mut self, checkpoint: &Checkpoint) {
  method revert (line 101) | fn revert(&mut self, checkpoint: &Checkpoint) {
  method revert (line 147) | fn revert(&mut self, checkpoint: &Checkpoint) {
  method after (line 173) | fn after(&self, checkpoint: &Checkpoint) -> bool {
  method after (line 187) | fn after(&self, checkpoint: &Checkpoint) -> bool {
  method after (line 199) | fn after(&self, checkpoint: &Checkpoint) -> bool {
  method after (line 209) | fn after(&self, checkpoint: &Checkpoint) -> bool {
  method after (line 217) | fn after(&self, checkpoint: &Checkpoint) -> bool {
  method revert (line 225) | fn revert(&mut self, checkpoint: &Checkpoint) {
  method revert (line 324) | fn revert(&mut self, checkpoint: &Checkpoint) {
  method revert (line 358) | fn revert(&mut self, checkpoint: &Checkpoint) {
  method revert (line 369) | fn revert(&mut self, checkpoint: &Checkpoint) {
  method revert (line 386) | fn revert(&mut self, checkpoint: &Checkpoint) {
  function revert_idx (line 395) | fn revert_idx<T: Idx>(option: &mut Option<T>, checkpoint: T) {
  function revert_fn (line 401) | fn revert_fn(builtin: &mut Option<FnId>, checkpoint: &Checkpoint) {
  method revert (line 410) | pub(crate) fn revert(&mut self, checkpoint: &Checkpoint) {

FILE: vine/src/structures/diag.rs
  type Diags (line 15) | pub struct Diags {
    method error (line 21) | pub(crate) fn error(&mut self, diag: Diag) -> ErrorGuaranteed {
    method warn (line 26) | pub(crate) fn warn(&mut self, diag: Diag) {
    method bail (line 30) | pub fn bail(&mut self) -> Result<(), ErrorGuaranteed> {
    method revert (line 34) | pub(crate) fn revert(&mut self, checkpoint: &Checkpoint) {
  function plural (line 342) | fn plural<'a>(n: usize, plural: &'a str, singular: &'a str) -> &'a str {
  method show_span (line 347) | pub fn show_span(&self, span: Span) -> Option<String> {
  type ErrorGuaranteed (line 353) | pub struct ErrorGuaranteed(());
    method new_unchecked (line 356) | pub const fn new_unchecked() -> Self {
    method from (line 407) | fn from(value: &ErrorGuaranteed) -> Self {
  method from (line 362) | fn from(value: ErrorGuaranteed) -> Self {
  type FileInfo (line 367) | pub struct FileInfo {
    method new (line 374) | pub fn new(name: String, src: String) -> Self {
    method get_pos (line 381) | pub fn get_pos(&self, byte: usize) -> Pos<'_> {
  type Pos (line 388) | pub struct Pos<'f> {
  method fmt (line 395) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 401) | fn from(value: ErrorGuaranteed) -> Self {

FILE: vine/src/structures/resolutions.rs
  type Resolutions (line 18) | pub struct Resolutions {
  type ResolvedImpl (line 27) | pub struct ResolvedImpl {
  type Become (line 34) | pub enum Become {
  type ResolvedImplKind (line 41) | pub enum ResolvedImplKind {
  type Fragment (line 51) | pub struct Fragment {
  type Rels (line 63) | pub struct Rels {
    method fork_rel (line 75) | pub fn fork_rel(&mut self, chart: &Chart, impl_: TirImpl) -> FnRelId {
    method drop_rel (line 80) | pub fn drop_rel(&mut self, chart: &Chart, impl_: TirImpl) -> FnRelId {
  type FnRel (line 69) | pub enum FnRel {

FILE: vine/src/structures/signatures.rs
  type Signatures (line 17) | pub struct Signatures {
    method const_sig (line 105) | pub fn const_sig(&self, const_id: ConstId) -> &TypeCtx<ConstSig> {
    method fn_sig (line 112) | pub fn fn_sig(&self, fn_id: FnId) -> &TypeCtx<FnSig> {
    method get_member (line 119) | pub fn get_member(&self, member: MemberKind) -> Option<DefId> {
  type ImportState (line 33) | pub enum ImportState {
  type TypeAliasState (line 40) | pub enum TypeAliasState {
  type TypeParams (line 48) | pub struct TypeParams {
  type ImplParams (line 54) | pub struct ImplParams {
  type ConstSig (line 60) | pub struct ConstSig {
  type FnSig (line 65) | pub struct FnSig {
  type TypeAliasSig (line 72) | pub struct TypeAliasSig {
  type StructSig (line 77) | pub struct StructSig {
  type EnumSig (line 82) | pub struct EnumSig {
  type UnionSig (line 88) | pub struct UnionSig {
  type TraitSig (line 94) | pub struct TraitSig {
  type ImplSig (line 100) | pub struct ImplSig {
  method transfer (line 131) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
  method transfer (line 137) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
  method transfer (line 147) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
  method transfer (line 153) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
  method transfer (line 159) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
  method transfer (line 168) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {

FILE: vine/src/structures/specializations.rs
  type Specializations (line 17) | pub struct Specializations {
    method spec (line 24) | pub fn spec(&self, spec_id: SpecId) -> &Spec {
  type Spec (line 31) | pub struct Spec {
  type SpecKind (line 40) | pub enum SpecKind {
  type SpecRels (line 46) | pub struct SpecRels {
  type ImplTree (line 52) | pub enum ImplTree {

FILE: vine/src/structures/template.rs
  type Template (line 13) | pub struct Template {
    method instantiate (line 18) | pub fn instantiate(&self, nets: &mut Nets, specs: &Specializations, sp...
  type TemplateStage (line 28) | pub struct TemplateStage {
    method instantiate (line 41) | pub fn instantiate(&self, specs: &Specializations, spec: &Spec) -> Net {
  type TemplateStageRels (line 34) | pub struct TemplateStageRels {
  function global_name (line 58) | pub fn global_name(spec: &Spec, stage_id: StageId) -> String {

FILE: vine/src/structures/tir.rs
  type Tir (line 21) | pub struct Tir {
  type TirClosure (line 31) | pub struct TirClosure {
  type TirLocal (line 40) | pub struct TirLocal {
  type TirExpr (line 46) | pub struct TirExpr {
    method new (line 195) | pub fn new(span: Span, ty: Type, kind: TirExprKind) -> Self {
  type TirExprKind (line 53) | pub enum TirExprKind {
  type TirExprLetKind (line 145) | pub enum TirExprLetKind {
  type TirPat (line 152) | pub struct TirPat {
    method new (line 201) | pub fn new(span: Span, ty: Type, kind: TirPatKind) -> Self {
  type TirPatKind (line 159) | pub enum TirPatKind {
  type TirImpl (line 183) | pub enum TirImpl {

FILE: vine/src/structures/types.rs
  type Type (line 24) | pub struct Type(usize);
    method new (line 29) | fn new(inv: Inverted, idx: TypeIdx) -> Type {
    method inv (line 33) | fn inv(self) -> Inverted {
    method idx (line 37) | fn idx(self) -> TypeIdx {
    method invert_if (line 41) | pub fn invert_if(self, inv: Inverted) -> Type {
    method inverse (line 45) | pub fn inverse(self) -> Type {
    method from (line 54) | fn from(value: TypeIdx) -> Self {
  constant INV_BIT (line 27) | const INV_BIT: usize = isize::MIN as usize;
  type Inverted (line 51) | pub struct Inverted(pub bool);
  type Output (line 60) | type Output = Self;
  method bitxor (line 61) | fn bitxor(self, rhs: Self) -> Self::Output {
  method bitxor_assign (line 67) | fn bitxor_assign(&mut self, rhs: Self) {
  method fmt (line 73) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type TypeKind (line 82) | pub enum TypeKind {
    method map (line 730) | fn map(&self, mut f: impl FnMut(Type) -> Type) -> Self {
    method children (line 760) | fn children(&self) -> impl Iterator<Item = Type> + '_ {
    method self_dual (line 783) | fn self_dual(&self) -> bool {
  type TypeNode (line 102) | enum TypeNode {
  type TypeState (line 115) | enum TypeState {
    method kind (line 128) | fn kind(&self) -> Option<(Inverted, &TypeKind)> {
    method take_kind (line 135) | fn take_kind(&mut self) -> Option<(Inverted, TypeKind)> {
  method default (line 147) | fn default() -> Self {
  type ImplType (line 153) | pub enum ImplType {
    method approx_eq (line 797) | pub fn approx_eq(&self, other: &ImplType) -> bool {
    method map (line 803) | fn map(&self, f: impl FnMut(Type) -> Type) -> Self {
  type Types (line 159) | pub struct Types {
    method new (line 167) | pub fn new(&mut self, kind: TypeKind) -> Type {
    method new_var (line 171) | pub fn new_var(&mut self, span: Span) -> Type {
    method new_struct (line 175) | pub fn new_struct(&mut self, chart: &Chart, struct_id: StructId, type_...
    method new_union (line 179) | pub fn new_union(&mut self, chart: &Chart, union_id: UnionId, type_par...
    method new_vars (line 183) | pub fn new_vars(&mut self, span: Span, len: usize) -> Vec<Type> {
    method error (line 187) | pub fn error(&mut self, err: ErrorGuaranteed) -> Type {
    method nil (line 193) | pub fn nil(&mut self) -> Type {
    method unify (line 202) | pub fn unify(&mut self, a: Type, b: Type) -> UnifyResult {
    method unify_types (line 300) | pub fn unify_types(&mut self, a: &[Type], b: &[Type], inv: Inverted) -...
    method unify_objects (line 308) | pub fn unify_objects(
    method unify_impl_type (line 319) | pub fn unify_impl_type(&mut self, a: &ImplType, b: &ImplType) -> Unify...
    method unify_fn_sig (line 329) | pub fn unify_fn_sig(&mut self, a: &FnSig, b: &FnSig) -> UnifyResult {
    method occurs (line 335) | fn occurs(&self, var: Type, ty: Type) -> bool {
    method find (line 344) | fn find(&self, ty: Type) -> Type {
    method find_mut (line 354) | fn find_mut(&mut self, ty: Type) -> Type {
    method kind (line 367) | pub(crate) fn kind(&self, ty: Type) -> Option<(Inverted, &TypeKind)> {
    method self_inverse (line 373) | pub(crate) fn self_inverse(&self, ty: Type) -> bool {
    method _self_inverse (line 377) | pub(crate) fn _self_inverse(
    method force_kind (line 393) | pub(crate) fn force_kind(&mut self, diags: &mut Diags, ty: Type) -> (I...
    method show (line 408) | pub fn show(&self, chart: &Chart, ty: Type) -> String {
    method _show (line 414) | fn _show(&self, chart: &Chart, mut ty: Type, str: &mut String) {
    method _show_params (line 524) | fn _show_params(&self, chart: &Chart, params: &[Type], inv: Inverted, ...
    method _show_comma_separated (line 532) | fn _show_comma_separated(&self, chart: &Chart, tys: &[Type], inv: Inve...
    method show_impl_type (line 543) | pub fn show_impl_type(&self, chart: &Chart, ty: &ImplType) -> String {
    method show_fn_sig (line 555) | pub fn show_fn_sig(&self, chart: &Chart, sig: &FnSig) -> String {
    method _show_fn_sig (line 561) | fn _show_fn_sig(&self, chart: &Chart, sig: &FnSig, str: &mut String) {
    method import (line 584) | pub fn import<T: TransferTypes>(&mut self, source: &TypeCtx<T>, params...
    method import_with (line 588) | pub fn import_with<T, U>(
    method export (line 600) | pub fn export<T>(&self, f: impl FnOnce(&mut TypeTransfer<'_>) -> T) ->...
    method get_mod (line 610) | pub fn get_mod(&self, chart: &Chart, ty: Type) -> Result<Option<DefId>...
    method reset (line 631) | pub fn reset(&mut self) {
    method finish_inference (line 637) | pub fn finish_inference(&mut self) {
  type UnifyResult (line 650) | pub enum UnifyResult {
    method and (line 659) | pub fn and(self, other: Self) -> Self {
    method all (line 667) | pub fn all(i: impl IntoIterator<Item = Self>) -> Self {
    method from_bool (line 671) | pub fn from_bool(b: bool) -> Self {
    method is_success (line 675) | pub fn is_success(self) -> bool {
    method is_failure (line 679) | pub fn is_failure(self) -> bool {
  type TypeTransfer (line 684) | pub struct TypeTransfer<'ctx> {
  function transfer (line 692) | pub fn transfer<T: TransferTypes>(&mut self, t: &T) -> T {
  function transfer_type (line 696) | fn transfer_type(&mut self, ty: Type) -> Type {
  function transfer_impl_type (line 724) | fn transfer_impl_type(&mut self, ty: &ImplType) -> ImplType {
  type TypeCtx (line 812) | pub struct TypeCtx<T> {
  type TransferTypes (line 817) | pub trait TransferTypes {
    method transfer (line 818) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self;
    method transfer (line 822) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
    method transfer (line 828) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
    method transfer (line 834) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
    method transfer (line 840) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {
    method transfer (line 846) | fn transfer(&self, t: &mut TypeTransfer<'_>) -> Self {

FILE: vine/src/structures/vir.rs
  constant NONE (line 33) | pub const NONE: LayerId = LayerId(usize::MAX);
  type Vir (line 37) | pub struct Vir {
  type Layer (line 48) | pub struct Layer {
  type Interface (line 55) | pub struct Interface {
    method new (line 67) | pub fn new(id: InterfaceId, layer: LayerId, kind: InterfaceKind) -> Se...
    method inline (line 79) | pub fn inline(&self) -> bool {
  type InterfaceKind (line 87) | pub enum InterfaceKind {
    method stages (line 96) | pub fn stages(&self) -> impl Iterator<Item = StageId> + use<> {
  type Stage (line 111) | pub struct Stage {
    method new_wire (line 257) | pub fn new_wire(&mut self, span: Span, ty: Type) -> Wire {
    method local_read_to (line 265) | pub fn local_read_to(&mut self, local: Local, span: Span, to: Port) {
    method local_write_to (line 269) | pub fn local_write_to(&mut self, local: Local, span: Span, to: Port) {
    method local_read_barrier_to (line 273) | pub fn local_read_barrier_to(&mut self, local: Local, span: Span, to: ...
    method local_barrier_write_to (line 277) | pub fn local_barrier_write_to(&mut self, local: Local, span: Span, to:...
    method local_read_write_to (line 281) | pub fn local_read_write_to(&mut self, local: Local, span: Span, o: Por...
    method local_read (line 285) | pub fn local_read(&mut self, local: Local, span: Span, ty: Type) -> Po...
    method local_write (line 291) | pub fn local_write(&mut self, local: Local, span: Span, ty: Type) -> P...
    method local_read_barrier (line 297) | pub fn local_read_barrier(&mut self, local: Local, span: Span, ty: Typ...
    method local_barrier_write (line 303) | pub fn local_barrier_write(&mut self, local: Local, span: Span, ty: Ty...
    method local_read_write (line 309) | pub fn local_read_write(&mut self, local: Local, span: Span, ty: Type)...
    method local_barrier (line 316) | pub fn local_barrier(&mut self, local: Local, span: Span) {
    method ext_fn (line 320) | pub fn ext_fn(
    method ref_place (line 334) | pub fn ref_place(&mut self, span: Span, ty: Type, (value, space): (Por...
  type Header (line 124) | pub enum Header {
    method ports (line 156) | pub fn ports(&self) -> impl Iterator<Item = &Port> {
  type Step (line 135) | pub enum Step {
    method ports (line 169) | pub fn ports(&self) -> impl Iterator<Item = &Port> {
  type Invocation (line 193) | pub enum Invocation {
    method ports (line 203) | fn ports(&self) -> impl Iterator<Item = &Port> {
  type Port (line 217) | pub struct Port {
    method error (line 223) | pub fn error(ty: Type, err: ErrorGuaranteed) -> Port {
  type PortKind (line 229) | pub enum PortKind {
  type Transfer (line 240) | pub struct Transfer {
    method unconditional (line 246) | pub fn unconditional(interface: InterfaceId) -> Transfer {
  type Wire (line 251) | pub struct Wire {
  type VirLocal (line 342) | pub struct VirLocal {
    method new (line 352) | pub fn new(

FILE: vine/src/tools/doc.rs
  function document (line 14) | pub fn document(compiler: &Compiler, path: &Path) -> Result<(), ()> {
  type Documenter (line 22) | struct Documenter<'a> {
  type Tree (line 26) | struct Tree<'a> {
  function build_tree (line 38) | fn build_tree(&self, id: DefId) -> Tree<'a> {
  function output_tree (line 105) | fn output_tree(&self, tree: &Tree, path: &Path, parent: Option<(&str, &s...
  function source_link (line 156) | fn source_link(&self, tree: &Tree) -> String {
  function write_header (line 168) | fn write_header(&self, tree: &Tree, str: &mut String) {

FILE: vine/src/tools/fmt.rs
  type Formatter (line 16) | pub struct Formatter<'src> {
  function fmt (line 21) | pub fn fmt(src: &str) -> Result<String, Diag> {
  function fmt_item (line 38) | pub(crate) fn fmt_item(&self, item: &Item) -> Doc<'src> {
  function fmt_vis (line 63) | pub(crate) fn fmt_vis(&self, vis: &Vis) -> Doc<'src> {
  function _fmt_vis (line 67) | pub(crate) fn _fmt_vis(&self, vis: &Vis) -> Doc<'src> {
  function fmt_block_like (line 75) | pub(crate) fn fmt_block_like(
  function line_break_separated (line 94) | fn line_break_separated(
  function get_line_break (line 115) | fn get_line_break(
  function fmt_stmt (line 148) | pub(crate) fn fmt_stmt(&self, stmt: &Stmt) -> Doc<'src> {
  function fmt_flex (line 163) | pub(crate) fn fmt_flex(&self, flex: Flex) -> Doc<'src> {
  function fmt_impl (line 167) | pub(crate) fn fmt_impl(&self, impl_: &Impl) -> Doc<'src> {
  function fmt_trait (line 177) | pub(crate) fn fmt_trait(&self, trait_: &Trait) -> Doc<'src> {
  function fmt_expr (line 193) | pub(crate) fn fmt_expr(&self, expr: &Expr) -> Doc<'src> {
  function fmt_pat (line 249) | pub(crate) fn fmt_pat(&self, pat: &Pat) -> Doc<'src> {
  function fmt_ty (line 265) | pub(crate) fn fmt_ty(&self, ty: &Ty) -> Doc<'src> {
  function fmt_arrow_ty (line 282) | pub(crate) fn fmt_arrow_ty(&self, ty: &Option<Ty>) -> Doc<'src> {
  function fmt_verbatim (line 289) | pub(crate) fn fmt_verbatim(&self, span: Span) -> Doc<'src> {

FILE: vine/src/tools/fmt/doc.rs
  constant MAX_WIDTH (line 5) | const MAX_WIDTH: usize = 100;
  type Doc (line 8) | pub struct Doc<'src> {
  function Doc (line 14) | pub fn Doc<'src>(doc: impl Into<Doc<'src>>) -> Doc<'src> {
  constant EMPTY (line 19) | pub const EMPTY: Self = Doc { measure: Measure::EMPTY, kind: DocKind::St...
  constant LINE (line 20) | pub const LINE: Self = Doc { measure: Measure::LINE, kind: DocKind::Line };
  function collect (line 22) | fn collect(docs: impl IntoIterator<Item = Self>) -> Box<[Self]> {
  function concat (line 26) | pub fn concat(docs: impl IntoIterator<Item = Self>) -> Self {
  function concat_vec (line 30) | pub fn concat_vec(docs: Vec<Self>) -> Self {
  function indent (line 34) | pub fn indent(docs: impl IntoIterator<Item = Self>) -> Self {
  function indent_vec (line 38) | pub fn indent_vec(docs: Vec<Self>) -> Self {
  function group (line 42) | pub fn group(docs: impl IntoIterator<Item = Self>) -> Self {
  function lazy_group (line 46) | pub fn lazy_group(docs: impl IntoIterator<Item = Self>) -> Self {
  function bare_group (line 50) | pub fn bare_group(docs: impl IntoIterator<Item = Self>) -> Self {
  function interleave (line 54) | pub fn interleave(docs: impl IntoIterator<Item = Self>, sep: Self) -> Se...
  function if_single (line 58) | pub fn if_single(str: &'src str) -> Self {
  function if_multi (line 62) | pub fn if_multi(str: &'src str) -> Self {
  function soft_line (line 66) | pub fn soft_line(str: &'src str) -> Self {
  function paren (line 70) | pub fn paren(doc: Self) -> Self {
  function delimited (line 74) | pub fn delimited(
  function paren_comma (line 101) | pub fn paren_comma(docs: impl ExactSizeIterator<Item = Self>) -> Self {
  function tuple (line 105) | pub fn tuple(docs: impl ExactSizeIterator<Item = Self>) -> Self {
  function bracket_comma (line 109) | pub fn bracket_comma(docs: impl ExactSizeIterator<Item = Self>) -> Self {
  function brace_comma (line 113) | pub fn brace_comma(docs: impl ExactSizeIterator<Item = Self>) -> Self {
  function brace_comma_space (line 117) | pub fn brace_comma_space(docs: impl ExactSizeIterator<Item = Self>) -> S...
  function brace_comma_multiline (line 121) | pub fn brace_comma_multiline(docs: impl ExactSizeIterator<Item = Self>) ...
  function brace_multiline (line 125) | pub fn brace_multiline(docs: impl Iterator<Item = Self>) -> Self {
  function from (line 136) | fn from(kind: DocKind<'src>) -> Self {
  function from (line 142) | fn from(str: &'src str) -> Self {
  function from (line 148) | fn from(str: String) -> Self {
  function from (line 154) | fn from(value: Ident) -> Self {
  type DocKind (line 160) | enum DocKind<'src> {
  function measure (line 175) | fn measure(&self) -> Measure {
  type Writer (line 194) | pub struct Writer {
    method write_doc (line 201) | pub fn write_doc(&mut self, doc: &Doc, multi: bool) {
    method write_all_maybe_indented (line 248) | fn write_all_maybe_indented(&mut self, docs: &[Doc], multi: bool) {
    method write_all_indented (line 256) | fn write_all_indented(&mut self, docs: &[Doc], multi: bool) {
    method write_all (line 262) | fn write_all(&mut self, docs: &[Doc], multi: bool) {
    method indent (line 268) | fn indent(&mut self) {
    method outdent (line 273) | fn outdent(&mut self) {
    method newline (line 278) | pub(crate) fn newline(&mut self) {
    method write_str (line 283) | fn write_str(&mut self, str: &str) {
    method remaining (line 296) | fn remaining(&self) -> usize {
  type Measure (line 302) | struct Measure {
    constant EMPTY (line 309) | const EMPTY: Self = Measure { multi: false, width: 0, leading: 0 };
    constant LINE (line 310) | const LINE: Self = Measure { multi: true, width: 0, leading: 0 };
    method string (line 312) | fn string(str: &str) -> Self {
    type Output (line 334) | type Output = Measure;
    method add (line 336) | fn add(self, rhs: Measure) -> Self::Output {

FILE: vine/src/tools/repl.rs
  type Repl (line 33) | pub struct Repl<'ctx, 'ivm, 'ext, 'comp> {
  type ScopeEntry (line 44) | struct ScopeEntry<'ivm> {
  function new (line 53) | pub fn new(
  function exec (line 86) | pub fn exec(&mut self, input: &str) -> Result<(), ErrorGuaranteed> {
  function run (line 113) | pub fn run(
  function parse_input (line 312) | fn parse_input(&mut self, line: &str) -> Result<(Span, ReplCommand), Dia...
  function print_scope (line 321) | pub fn print_scope(&mut self) {

FILE: vine/src/tools/repl/command.rs
  type ReplCommand (line 11) | pub enum ReplCommand {
  type ReplOptions (line 19) | pub struct ReplOptions {
  method default (line 24) | fn default() -> Self {
  type ReplOption (line 29) | pub enum ReplOption {
  constant HELP (line 33) | pub const HELP: &str = "
  function parse_repl_command (line 43) | pub(super) fn parse_repl_command(&mut self) -> Result<ReplCommand, Diag> {
  function parse_bool (line 76) | fn parse_bool(&mut self) -> Result<bool, Diag> {

FILE: vine/src/tools/repl/show.rs
  function show (line 23) | pub fn show(&mut self, ty: Type, port: &mut Port<'ivm>) -> String {
  function _show (line 29) | fn _show(&mut self, ty: Type, port: Port<'ivm>) -> (Port<'ivm>, Option<S...
  function read_string (line 99) | fn read_string(&mut self, tree: &Tree) -> Option<String> {