SYMBOL INDEX (3985 symbols across 229 files)

FILE: libeir_diagnostics/src/codemap.rs
  type CodeMap (line 11) | pub struct CodeMap {
    method new (line 19) | pub fn new() -> Self {
    method add (line 30) | pub fn add(&self, name: impl Into<FileName>, source: String) -> Source...
    method add_child (line 54) | pub fn add_child(
    method insert_file (line 63) | fn insert_file(&self, name: FileName, source: String, parent: Option<S...
    method get (line 75) | pub fn get(&self, file_id: SourceId) -> Option<Arc<SourceFile>> {
    method parent (line 83) | pub fn parent(&self, file_id: SourceId) -> Option<SourceSpan> {
    method get_file_id (line 88) | pub fn get_file_id(&self, filename: &FileName) -> Option<SourceId> {
    method get_by_name (line 93) | pub fn get_by_name(&self, filename: &FileName) -> Option<Arc<SourceFil...
    method name (line 97) | pub fn name(&self, file_id: SourceId) -> Option<FileName> {
    method iter (line 101) | pub fn iter<'a>(&'a self) -> impl Iterator<Item = Arc<SourceFile>> + 'a {
    method line_span (line 105) | pub fn line_span(
    method line_index (line 114) | pub fn line_index(
    method location (line 123) | pub fn location(
    method source_span (line 132) | pub fn source_span(&self, file_id: SourceId) -> Option<SourceSpan> {
    method source_slice (line 137) | pub fn source_slice<'a>(
    method next_file_id (line 150) | fn next_file_id(&self) -> SourceId {
    type FileId (line 161) | type FileId = SourceId;
    type Name (line 162) | type Name = String;
    type Source (line 163) | type Source = &'a str;
    method name (line 165) | fn name(&self, file_id: Self::FileId) -> Option<Self::Name> {
    method source (line 169) | fn source(&self, file_id: Self::FileId) -> Option<&'a str> {
    method line_index (line 176) | fn line_index(&self, file_id: Self::FileId, byte_index: usize) -> Opti...
    method line_range (line 180) | fn line_range(&self, file_id: Self::FileId, line_index: usize) -> Opti...
  method default (line 156) | fn default() -> Self {

FILE: libeir_diagnostics/src/filename.rs
  type FileName (line 8) | pub enum FileName {
    method from (line 16) | fn from(name: PathBuf) -> FileName {
    method from (line 41) | fn from(name: &Path) -> FileName {
    method from (line 47) | fn from(name: String) -> FileName {
    method from (line 53) | fn from(name: &'static str) -> FileName {
    method as_ref (line 59) | fn as_ref(&self) -> &Path {
    method eq (line 68) | fn eq(&self, other: &Path) -> bool {
    method eq (line 74) | fn eq(&self, other: &PathBuf) -> bool {
    method real (line 80) | pub fn real<T: Into<PathBuf>>(name: T) -> FileName {
    method virtual_ (line 84) | pub fn virtual_<T: Into<Cow<'static, str>>>(name: T) -> FileName {
    method to_string (line 88) | pub fn to_string(&self) -> String {
    method fmt (line 100) | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  method from (line 22) | fn from(name: FileName) -> PathBuf {
  function from (line 32) | fn from(name: &'a FileName) -> &'a Path {

FILE: libeir_diagnostics/src/index.rs
  type SourceIndex (line 9) | pub struct SourceIndex(NonZeroUsize);
    constant INDEX_MASK (line 11) | const INDEX_MASK: usize = u32::max_value() as usize;
    constant UNKNOWN_SRC_ID (line 13) | const UNKNOWN_SRC_ID: usize = (SourceId::UNKNOWN_SOURCE_ID as usize) <...
    constant UNKNOWN (line 15) | pub const UNKNOWN: Self = Self(unsafe { NonZeroUsize::new_unchecked(Se...
    method new (line 18) | pub fn new(source: SourceId, index: ByteIndex) -> Self {
    method source_id (line 25) | pub fn source_id(&self) -> SourceId {
    method index (line 35) | pub fn index(&self) -> ByteIndex {
    method to_usize (line 39) | pub fn to_usize(&self) -> usize {
    type Output (line 50) | type Output = SourceIndex;
    method add (line 53) | fn add(self, rhs: usize) -> Self {
    type Output (line 65) | type Output = SourceIndex;
    method add (line 68) | fn add(self, rhs: ByteOffset) -> Self {
    method add_assign (line 81) | fn add_assign(&mut self, rhs: usize) {
    method add_assign (line 88) | fn add_assign(&mut self, rhs: ByteOffset) {
    type Output (line 94) | type Output = SourceIndex;
    method sub (line 97) | fn sub(self, rhs: usize) -> Self {
    method sub_assign (line 110) | fn sub_assign(&mut self, rhs: usize) {
  method default (line 44) | fn default() -> Self {

FILE: libeir_diagnostics/src/lib.rs
  type Diagnostic (line 27) | pub type Diagnostic = codespan_reporting::diagnostic::Diagnostic<SourceId>;
  type Label (line 28) | pub type Label = codespan_reporting::diagnostic::Label<SourceId>;
  type ToDiagnostic (line 30) | pub trait ToDiagnostic {
    method to_diagnostic (line 31) | fn to_diagnostic(&self) -> Diagnostic;

FILE: libeir_diagnostics/src/source.rs
  type SourceId (line 9) | pub struct SourceId(crate NonZeroU32);
    constant UNKNOWN_SOURCE_ID (line 11) | crate const UNKNOWN_SOURCE_ID: u32 = u32::max_value();
    constant UNKNOWN (line 13) | pub const UNKNOWN: Self = Self(unsafe { NonZeroU32::new_unchecked(Self...
    method new (line 15) | crate fn new(index: u32) -> Self {
    method get (line 22) | crate fn get(self) -> u32 {
  type SourceFile (line 29) | pub struct SourceFile {
    method new (line 37) | crate fn new(id: SourceId, name: FileName, source: String, parent: Opt...
    method name (line 51) | pub fn name(&self) -> &FileName {
    method id (line 55) | pub fn id(&self) -> SourceId {
    method parent (line 59) | pub fn parent(&self) -> Option<SourceSpan> {
    method line_start (line 63) | pub fn line_start(
    method last_line_index (line 79) | pub fn last_line_index(&self) -> LineIndex {
    method line_span (line 83) | pub fn line_span(&self, line_index: LineIndex) -> Result<Span, LineInd...
    method line_index (line 90) | pub fn line_index(&self, byte_index: ByteIndex) -> LineIndex {
    method location (line 98) | pub fn location(&self, byte_index: ByteIndex) -> Result<Location, Loca...
    method source (line 130) | pub fn source(&self) -> &str {
    method source_span (line 134) | pub fn source_span(&self) -> SourceSpan {
    method source_slice (line 142) | pub fn source_slice(

FILE: libeir_diagnostics/src/span.rs
  type SourceSpan (line 8) | pub struct SourceSpan {
    constant UNKNOWN (line 14) | pub const UNKNOWN: Self = Self {
    method new (line 21) | pub fn new(start: SourceIndex, end: SourceIndex) -> Self {
    method new_align (line 38) | pub fn new_align<F>(
    method source_id (line 82) | pub fn source_id(&self) -> SourceId {
    method start (line 87) | pub fn start(&self) -> SourceIndex {
    method start_index (line 92) | pub fn start_index(&self) -> ByteIndex {
    method shrink_front (line 96) | pub fn shrink_front(mut self, offset: ByteOffset) -> Self {
    method end (line 102) | pub fn end(&self) -> SourceIndex {
    method end_index (line 107) | pub fn end_index(&self) -> ByteIndex {
    method as_span (line 111) | pub fn as_span(&self) -> Span {
  function from (line 117) | fn from(span: SourceSpan) -> Range<usize> {
  function from (line 123) | fn from(span: SourceSpan) -> Range<SourceIndex> {

FILE: libeir_frontend/src/abstr_erlang.rs
  type Error (line 12) | pub enum Error {
    method from (line 25) | fn from(err: ParseError) -> Error {
    method from (line 30) | fn from(err: LowerError) -> Error {
  method to_diagnostic (line 17) | fn to_diagnostic(&self) -> Diagnostic {
  type AbstrErlangFrontend (line 35) | pub struct AbstrErlangFrontend {
    method new (line 39) | pub fn new(codemap: Arc<CodeMap>) -> Self {
  type Error (line 46) | type Error = Error;
  method parse_source (line 48) | fn parse_source<'a>(
  method parse_string (line 67) | fn parse_string<'a>(
  method parse_file (line 77) | fn parse_file<'a>(

FILE: libeir_frontend/src/eir.rs
  type Error (line 13) | pub enum Error {
    method from (line 26) | fn from(err: ParserError) -> Self {
    method from (line 31) | fn from(err: LowerError) -> Self {
  method to_diagnostic (line 18) | fn to_diagnostic(&self) -> Diagnostic {
  type EirFrontend (line 36) | pub struct EirFrontend {
    method new (line 40) | pub fn new(codemap: Arc<CodeMap>) -> Self {
  type Error (line 47) | type Error = Error;
  method parse_source (line 49) | fn parse_source<'a>(
  method parse_string (line 63) | fn parse_string<'a>(
  method parse_file (line 73) | fn parse_file<'a>(

FILE: libeir_frontend/src/erlang.rs
  type Error (line 13) | pub enum Error {
  method to_diagnostic (line 18) | fn to_diagnostic(&self) -> Diagnostic {
  method into (line 26) | fn into(self) -> Error {
  method into (line 31) | fn into(self) -> Error {
  type ErlangFrontend (line 36) | pub struct ErlangFrontend {
    method new (line 41) | pub fn new(config: ParseConfig, codemap: Arc<CodeMap>) -> Self {
  type Error (line 49) | type Error = Error;
  method parse_source (line 51) | fn parse_source<'a>(
  method parse_string (line 69) | fn parse_string<'a>(
  method parse_file (line 79) | fn parse_file<'a>(

FILE: libeir_frontend/src/lib.rs
  type FrontendErrorReceiver (line 15) | pub type FrontendErrorReceiver<'a, E> = dyn ErrorReceiver<E = E, W = E> ...
  type DynFrontend (line 17) | pub trait DynFrontend {
    method parse_source_dyn (line 18) | fn parse_source_dyn<'a>(
    method parse_string_dyn (line 23) | fn parse_string_dyn<'a>(&self, source: &str) -> (Result<Module, ()>, V...
    method parse_file_dyn (line 25) | fn parse_file_dyn<'a>(&self, source: &Path) -> (Result<Module, ()>, Ve...
    method parse_source_dyn (line 55) | fn parse_source_dyn<'a>(
    method parse_string_dyn (line 64) | fn parse_string_dyn<'a>(&self, source: &str) -> (Result<Module, ()>, V...
    method parse_file_dyn (line 70) | fn parse_file_dyn<'a>(&self, source: &Path) -> (Result<Module, ()>, Ve...
    method parse_source_dyn (line 86) | fn parse_source_dyn<'a>(
    method parse_string_dyn (line 100) | fn parse_string_dyn<'a>(&self, source: &str) -> (Result<Module, ()>, V...
    method parse_file_dyn (line 111) | fn parse_file_dyn<'a>(&self, source: &Path) -> (Result<Module, ()>, Ve...
  type Frontend (line 28) | pub trait Frontend {
    method parse_source (line 31) | fn parse_source<'a>(
    method parse_string (line 37) | fn parse_string<'a>(
    method parse_file (line 43) | fn parse_file<'a>(
  type AnyFrontend (line 77) | pub enum AnyFrontend {
    method from (line 123) | fn from(f: erlang::ErlangFrontend) -> Self {
    method from (line 128) | fn from(f: abstr_erlang::AbstrErlangFrontend) -> Self {
    method from (line 133) | fn from(f: eir::EirFrontend) -> Self {

FILE: libeir_intern/src/arena.rs
  type TypedArena (line 25) | pub struct TypedArena<T> {
  type TypedArenaChunk (line 41) | struct TypedArenaChunk<T> {
  function new (line 48) | unsafe fn new(capacity: usize) -> TypedArenaChunk<T> {
  function destroy (line 56) | unsafe fn destroy(&mut self, len: usize) {
  function start (line 71) | fn start(&self) -> *mut T {
  function end (line 77) | fn end(&self) -> *mut T {
  constant PAGE (line 90) | const PAGE: usize = 4 * 1024;
  constant PAGE (line 93) | const PAGE: usize = 64 * 1024;
  method default (line 97) | fn default() -> TypedArena<T> {
  function in_arena (line 110) | pub fn in_arena(&self, ptr: *const T) -> bool {
  function alloc (line 120) | pub fn alloc(&self, object: T) -> &mut T {
  function alloc_slice (line 152) | pub fn alloc_slice(&self, slice: &[T]) -> &mut [T]
  function grow (line 177) | fn grow(&self, n: usize) {
  function clear (line 203) | pub fn clear(&mut self) {
  function clear_last_chunk (line 221) | fn clear_last_chunk(&self, last_chunk: &mut TypedArenaChunk<T>) {
  method drop (line 246) | fn drop(&mut self) {
  type DroplessArena (line 266) | pub struct DroplessArena {
    method in_arena (line 292) | pub fn in_arena<T: ?Sized>(&self, ptr: *const T) -> bool {
    method align (line 302) | fn align(&self, align: usize) {
    method grow (line 310) | fn grow(&self, needed_bytes: usize) {
    method alloc_raw (line 334) | pub unsafe fn alloc_raw(&self, bytes: usize, align: usize) -> *mut u8 {
    method alloc_copy (line 353) | pub fn alloc_copy<T>(&self, object: T) -> &mut T {
    method alloc_slice (line 373) | pub fn alloc_slice<T>(&self, slice: &[T]) -> &mut [T]
  method default (line 282) | fn default() -> DroplessArena {
  type Point (line 405) | struct Point {
  function test_unused (line 412) | pub fn test_unused() {
  function test_arena_alloc_nested (line 418) | fn test_arena_alloc_nested() {
  function test_copy (line 461) | pub fn test_copy() {
  function bench_copy (line 469) | pub fn bench_copy(b: &mut Bencher) {
  function bench_copy_nonarena (line 475) | pub fn bench_copy_nonarena(b: &mut Bencher) {
  type Noncopy (line 482) | struct Noncopy {
  function test_noncopy (line 488) | pub fn test_noncopy() {
  function test_typed_arena_zero_sized (line 499) | pub fn test_typed_arena_zero_sized() {
  function test_typed_arena_clear (line 507) | pub fn test_typed_arena_clear() {
  function bench_typed_arena_clear (line 518) | pub fn bench_typed_arena_clear(b: &mut Bencher) {
  type DropCounter (line 528) | struct DropCounter<'a> {
  method drop (line 533) | fn drop(&mut self) {
  function test_typed_arena_drop_count (line 539) | fn test_typed_arena_drop_count() {
  function test_typed_arena_drop_on_clear (line 552) | fn test_typed_arena_drop_on_clear() {
  type SmallDroppable (line 567) | struct SmallDroppable;
  method drop (line 570) | fn drop(&mut self) {
  function test_typed_arena_drop_small_count (line 576) | fn test_typed_arena_drop_small_count() {
  function bench_noncopy (line 590) | pub fn bench_noncopy(b: &mut Bencher) {
  function bench_noncopy_nonarena (line 601) | pub fn bench_noncopy_nonarena(b: &mut Bencher) {

FILE: libeir_intern/src/lib.rs
  function it_works (line 19) | fn it_works() {

FILE: libeir_intern/src/symbol.rs
  type SymbolTable (line 27) | pub struct SymbolTable {
    method new (line 31) | pub fn new() -> Self {
  type Ident (line 40) | pub struct Ident {
    method new (line 47) | pub const fn new(name: Symbol, span: SourceSpan) -> Ident {
    method with_empty_span (line 52) | pub const fn with_empty_span(name: Symbol) -> Ident {
    method from_interned_str (line 57) | pub fn from_interned_str(string: InternedString) -> Ident {
    method from_str (line 62) | pub fn from_str(string: &str) -> Ident {
    method unquote_string (line 66) | pub fn unquote_string(self) -> Ident {
    method unquote_atom (line 70) | pub fn unquote_atom(self) -> Ident {
    method gensym (line 74) | pub fn gensym(self) -> Ident {
    method as_str (line 78) | pub fn as_str(self) -> LocalInternedString {
    method as_interned_str (line 82) | pub fn as_interned_str(self) -> InternedString {
    method fmt (line 106) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 112) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method is_keyword (line 435) | pub fn is_keyword(self) -> bool {
    method is_reserved_attr (line 439) | pub fn is_reserved_attr(self) -> bool {
    method is_preprocessor_directive (line 443) | pub fn is_preprocessor_directive(self) -> bool {
  method partial_cmp (line 88) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 94) | fn eq(&self, rhs: &Self) -> bool {
  method hash (line 100) | fn hash<H: Hasher>(&self, state: &mut H) {
  type SymbolIndex (line 118) | pub struct SymbolIndex(u32);
    constant MAX_AS_U32 (line 138) | pub const MAX_AS_U32: u32 = 0xFFFF_FF00;
    constant MAX (line 140) | pub const MAX: SymbolIndex = SymbolIndex::new(0xFFFF_FF00);
    method new (line 143) | const fn new(n: u32) -> Self {
    method as_u32 (line 154) | pub fn as_u32(self) -> u32 {
    method as_usize (line 159) | pub fn as_usize(self) -> usize {
  method clone (line 120) | fn clone(&self) -> Self {
  function from (line 126) | fn from(v: SymbolIndex) -> u32 {
  function from (line 132) | fn from(v: SymbolIndex) -> usize {
  type Symbol (line 166) | pub struct Symbol(SymbolIndex);
    method new (line 169) | const fn new(n: u32) -> Self {
    method intern (line 174) | pub fn intern(string: &str) -> Self {
    method interned (line 178) | pub fn interned(self) -> Self {
    method gensym (line 183) | pub fn gensym(string: &str) -> Self {
    method gensymed (line 187) | pub fn gensymed(self) -> Self {
    method as_str (line 191) | pub fn as_str(self) -> LocalInternedString {
    method as_interned_str (line 200) | pub fn as_interned_str(self) -> InternedString {
    method as_u32 (line 207) | pub fn as_u32(self) -> u32 {
    method as_usize (line 212) | pub fn as_usize(self) -> usize {
    method fmt (line 218) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 229) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method eq (line 235) | fn eq(&self, other: &T) -> bool {
    method is_keyword (line 419) | pub fn is_keyword(self) -> bool {
    method is_reserved_attr (line 424) | pub fn is_reserved_attr(self) -> bool {
    method is_preprocessor_directive (line 429) | pub fn is_preprocessor_directive(self) -> bool {
  type Interner (line 245) | pub struct Interner {
    method prefill (line 253) | fn prefill(init: &[&str]) -> Self {
    method intern (line 268) | pub fn intern(&mut self, string: &str) -> Symbol {
    method interned (line 287) | pub fn interned(&self, symbol: Symbol) -> Symbol {
    method gensym (line 295) | fn gensym(&mut self, string: &str) -> Symbol {
    method gensymed (line 300) | fn gensymed(&mut self, symbol: Symbol) -> Symbol {
    method is_gensymed (line 305) | fn is_gensymed(&mut self, symbol: Symbol) -> bool {
    method get (line 309) | pub fn get(&self, symbol: Symbol) -> &str {
  function with_interner (line 450) | fn with_interner<T, F: FnOnce(&mut Interner) -> T>(f: F) -> T {
  function with_read_only_interner (line 462) | fn with_read_only_interner<T, F: FnOnce(&Interner) -> T>(f: F) -> T {
  type LocalInternedString (line 474) | pub struct LocalInternedString {
    method as_interned_str (line 482) | pub fn as_interned_str(self) -> InternedString {
    method get (line 488) | pub fn get(&self) -> &'static str {
    method as_ref (line 497) | fn as_ref(&self) -> &U {
    method eq (line 503) | fn eq(&self, other: &T) -> bool {
    type Target (line 536) | type Target = str;
    method deref (line 537) | fn deref(&self) -> &str {
    method fmt (line 543) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 549) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function eq (line 509) | fn eq(&self, other: &LocalInternedString) -> bool {
  function eq (line 515) | fn eq(&self, other: &LocalInternedString) -> bool {
  method eq (line 521) | fn eq(&self, other: &LocalInternedString) -> bool {
  function eq (line 527) | fn eq(&self, other: &LocalInternedString) -> bool {
  type InternedString (line 556) | pub struct InternedString {
    method with (line 561) | pub fn with<F: FnOnce(&str) -> R, R>(self, f: F) -> R {
    method as_symbol (line 569) | pub fn as_symbol(self) -> Symbol {
    method as_str (line 573) | pub fn as_str(self) -> LocalInternedString {
    method partial_cmp (line 585) | fn partial_cmp(&self, other: &InternedString) -> Option<Ordering> {
    method eq (line 603) | fn eq(&self, other: &T) -> bool {
    method eq (line 609) | fn eq(&self, other: &InternedString) -> bool {
    method fmt (line 645) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 651) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method hash (line 579) | fn hash<H: Hasher>(&self, state: &mut H) {
  method cmp (line 594) | fn cmp(&self, other: &InternedString) -> Ordering {
  function eq (line 615) | fn eq(&self, other: &InternedString) -> bool {
  function eq (line 621) | fn eq(&self, other: &InternedString) -> bool {
  method eq (line 627) | fn eq(&self, other: &InternedString) -> bool {
  function eq (line 633) | fn eq(&self, other: &InternedString) -> bool {
  method from (line 639) | fn from(val: InternedString) -> String {
  function interner_tests (line 661) | fn interner_tests() {
  function interned_keywords_no_gaps (line 680) | fn interned_keywords_no_gaps() {
  function unquote_string (line 691) | fn unquote_string() {
  function unquote_atom (line 697) | fn unquote_atom() {

FILE: libeir_interpreter/src/erl_lib/erlang.rs
  function abs (line 16) | fn abs(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function add (line 31) | fn add(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function sub (line 66) | fn sub(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function invert (line 99) | fn invert(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) ...
  function mul (line 114) | fn mul(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function div (line 129) | fn div(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function is_list (line 150) | fn is_list(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>])...
  function is_atom (line 169) | fn is_atom(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>])...
  function is_integer (line 185) | fn is_integer(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term...
  function is_pid (line 198) | fn is_pid(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) ...
  function is_tuple (line 211) | fn is_tuple(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]...
  function is_map (line 224) | fn is_map(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) ...
  function list_subtract (line 257) | fn list_subtract(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<T...
  function exact_eq (line 288) | fn exact_eq(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]...
  function exact_not_eq (line 294) | fn exact_not_eq(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Te...
  function and (line 301) | fn and(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function or (line 312) | fn or(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> N...
  function tuple_size (line 323) | fn tuple_size(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term...
  function is_function (line 334) | fn is_function(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Ter...
  function not (line 474) | fn not(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function is_binary (line 485) | fn is_binary(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>...
  function atom_to_list (line 502) | fn atom_to_list(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Te...
  function less_than_or_equal (line 521) | fn less_than_or_equal(
  function less_than (line 534) | fn less_than(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>...
  function greater_than_or_equal (line 543) | fn greater_than_or_equal(
  function greater_than (line 556) | fn greater_than(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Te...
  function setelement (line 566) | fn setelement(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term...
  function element (line 588) | fn element(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>])...
  function erl_self (line 608) | fn erl_self(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc<Term>])...
  function put (line 628) | fn put(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc<Term>]) -> N...
  function get (line 642) | fn get(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc<Term>]) -> N...
  function erase (line 655) | fn erase(_vm: &VMState, proc: &mut ProcessContext, args: &[Rc<Term>]) ->...
  function length (line 673) | fn length(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) ...
  function hd (line 698) | fn hd(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> N...
  function tl (line 712) | fn tl(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> N...
  function map_size (line 727) | fn map_size(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]...
  function make_erlang (line 738) | pub fn make_erlang() -> NativeModule {

FILE: libeir_interpreter/src/erl_lib/file.rs
  function delete (line 6) | fn delete(_vm: &VMState, _proc: &mut ProcessContext, args: &[Term]) -> C...
  function make_time (line 13) | pub fn make_time() -> NativeModule {

FILE: libeir_interpreter/src/erl_lib/lists.rs
  function reverse_2 (line 30) | fn reverse_2(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>...
  function reverse_1 (line 42) | fn reverse_1(vm: &VMState, proc: &mut ProcessContext, args: &[Rc<Term>])...
  function make_lists (line 73) | pub fn make_lists() -> NativeModule {

FILE: libeir_interpreter/src/erl_lib/maps.rs
  function new_0 (line 11) | fn new_0(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -...
  function from_list_1 (line 18) | fn from_list_1(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Ter...
  function make_maps (line 40) | pub fn make_maps() -> NativeModule {

FILE: libeir_interpreter/src/erl_lib/math.rs
  function pow (line 12) | fn pow(_vm: &VMState, _proc: &mut ProcessContext, args: &[Rc<Term>]) -> ...
  function make_math (line 29) | pub fn make_math() -> NativeModule {

FILE: libeir_interpreter/src/erl_lib/os.rs
  function getenv (line 6) | fn getenv(_vm: &VMState, _proc: &mut ProcessContext, args: &[Term]) -> C...
  function os_type (line 14) | fn os_type(_vm: &VMState, _proc: &mut ProcessContext, args: &[Term]) -> ...
  function make_os (line 22) | pub fn make_os() -> NativeModule {

FILE: libeir_interpreter/src/erl_tests/mod.rs
  function erl_to_core (line 8) | fn erl_to_core(erlang_code: &str) -> String {
  function erl_to_ir (line 38) | fn erl_to_ir(erlang_code: &str) -> Module {
  function ctx_from_erl (line 49) | fn ctx_from_erl(erlang_code: &str) -> VMState {
  constant TEST_ERL_1 (line 60) | const TEST_ERL_1: &str = r##"
  function simple_add (line 94) | fn simple_add() {
  function simple_function_call (line 104) | fn simple_function_call() {
  function simple_lambda (line 114) | fn simple_lambda() {
  function simple_pattern_match (line 124) | fn simple_pattern_match() {
  constant FACTORIAL_ERL (line 139) | const FACTORIAL_ERL: &str = r##"
  function factorial (line 149) | fn factorial() {
  function long_strings (line 159) | fn long_strings() {
  function compile_core_file (line 172) | fn compile_core_file(path: &str) -> Module {
  function compiler (line 182) | fn compiler() {

FILE: libeir_interpreter/src/mailbox.rs
  type Mailbox (line 4) | pub struct Mailbox {
    method new (line 10) | pub fn new() -> Self {
    method get_trap_exits (line 16) | pub fn get_trap_exits(&self) -> bool {
    method set_trap_exits (line 19) | pub fn set_trap_exits(&mut self, val: bool) {

FILE: libeir_interpreter/src/module.rs
  type NativeReturn (line 10) | pub enum NativeReturn {
  type NativeModule (line 15) | pub struct NativeModule {
    method new (line 23) | pub fn new(name: Symbol) -> Self {
    method add_fun (line 30) | pub fn add_fun(
    method has_fun (line 39) | pub fn has_fun(&self, ident: &FunctionIdent) -> bool {
  type ErlangFunction (line 44) | pub struct ErlangFunction {
  type ErlangModule (line 49) | pub struct ErlangModule {
    method from_eir (line 55) | pub fn from_eir(module: Module) -> Self {
  type ModuleType (line 76) | pub enum ModuleType {

FILE: libeir_interpreter/src/pattern.rs
  type MatchState (line 10) | pub enum MatchState {
    method clause_num (line 18) | fn clause_num(&self) -> usize {
    method clause_num_mut (line 26) | fn clause_num_mut(&mut self) -> &mut usize {
    method into_guard (line 33) | fn into_guard(&mut self) {
    method into_body (line 40) | fn into_body(&mut self) {
    method into_finished (line 47) | fn into_finished(&mut self) {
  type CaseContext (line 54) | pub struct CaseContext {
    method new (line 151) | pub fn new(vars: Vec<Term>, clauses: Vec<Clause>) -> Self {
    method do_body (line 160) | pub fn do_body(&mut self) -> usize {
    method case_values (line 199) | pub fn case_values(&self) -> HashMap<SSAVariable, Term> {
    method guard_ok (line 203) | pub fn guard_ok(&mut self) {
    method guard_fail (line 207) | pub fn guard_fail(&mut self, clause_num: usize) {
  function match_node (line 61) | fn match_node(term: &Term, node: &PatternNode,

FILE: libeir_interpreter/src/process/match.rs
  function match_op (line 12) | pub fn match_op(

FILE: libeir_interpreter/src/process/mod.rs
  type TermCall (line 25) | pub struct TermCall {
  type Continuation (line 30) | pub enum Continuation {
  type CallExecutor (line 36) | pub struct CallExecutor {
    method new (line 41) | pub fn new() -> Self {
    method run (line 47) | pub fn run(&mut self, vm: &VMState, proc: &mut ProcessContext, call: T...
    method run_native (line 105) | pub fn run_native(
    method run_erlang (line 129) | pub fn run_erlang(
    method make_const_term (line 166) | fn make_const_term(&self, fun: &ErlangFunction, const_val: Const) -> R...
    method make_term (line 210) | fn make_term(&self, fun: &ErlangFunction, value: Value) -> Rc<Term> {
    method run_erlang_op (line 288) | pub fn run_erlang_op(&mut self, _vm: &VMState, fun: &ErlangFunction, b...
  type ProcessContext (line 572) | pub struct ProcessContext {
    method new (line 578) | pub fn new(pid: Pid) -> Self {

FILE: libeir_interpreter/src/receive.rs
  type ReceiveContext (line 4) | pub struct ReceiveContext {
    method new (line 9) | pub fn new(timeout: Term) -> Self {

FILE: libeir_interpreter/src/term.rs
  type Pid (line 16) | pub struct Pid(pub usize);
  type Reference (line 19) | pub struct Reference(pub usize);
  type TermType (line 22) | pub enum TermType {
  type FloatTerm (line 45) | pub struct FloatTerm(pub f64);
    method from (line 63) | fn from(src: f64) -> Self {
  method eq (line 47) | fn eq(&self, other: &FloatTerm) -> bool {
  method cmp (line 52) | fn cmp(&self, other: &FloatTerm) -> Ordering {
  method hash (line 58) | fn hash<T: Hasher>(&self, state: &mut T) {
  type MapTerm (line 69) | pub struct MapTerm {
    method new (line 74) | pub fn new() -> MapTerm {
    method insert (line 81) | pub fn insert(&mut self, key: Rc<Term>, val: Rc<Term>) -> bool {
    method get (line 95) | pub fn get(&self, key: &Rc<Term>) -> Option<Rc<Term>> {
    method len (line 99) | pub fn len(&self) -> usize {
  method eq (line 104) | fn eq(&self, other: &MapTerm) -> bool {
  method partial_cmp (line 110) | fn partial_cmp(&self, other: &MapTerm) -> Option<Ordering> {
  method cmp (line 115) | fn cmp(&self, other: &MapTerm) -> Ordering {
  method hash (line 120) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Term (line 126) | pub enum Term {
    method order_idx (line 158) | fn order_idx(&self) -> usize {
    method from (line 388) | fn from(num: i64) -> Self {
    method new_i64 (line 422) | pub fn new_i64(num: i64) -> Self {
    method new_usize (line 425) | pub fn new_usize(num: usize) -> Self {
    method new_atom (line 429) | pub fn new_atom(string: &str) -> Self {
    method new_bool (line 433) | pub fn new_bool(val: bool) -> Self {
    method slice_to_list (line 441) | pub fn slice_to_list(head: &[Rc<Term>], tail: Rc<Term>) -> Rc<Term> {
    method extend_erl_string (line 449) | fn extend_erl_string(&self, buf: &mut String) -> bool {
    method get_erl_string (line 469) | pub fn get_erl_string(&self) -> Option<String> {
    method atom_str (line 478) | pub fn atom_str<'a>(&'a self) -> LocalInternedString {
    method is_nil (line 486) | pub fn is_nil(&self) -> bool {
    method get_type (line 493) | pub fn get_type(&self) -> TermType {
    method as_boolean (line 514) | pub fn as_boolean(&self) -> Option<bool> {
    method as_i64 (line 528) | pub fn as_i64(&self) -> Option<i64> {
    method as_usize (line 536) | pub fn as_usize(&self) -> Option<usize> {
    method as_integer (line 544) | pub fn as_integer(&self) -> Option<&BigInt> {
    method as_atom (line 552) | pub fn as_atom(&self) -> Option<Symbol> {
    method as_tuple (line 560) | pub fn as_tuple(&self) -> Option<&[Rc<Term>]> {
    method as_binary (line 568) | pub fn as_binary(&self) -> Option<&BitVec> {
    method as_map (line 576) | pub fn as_map(&self) -> Option<&MapTerm> {
    method list_iter (line 584) | pub fn list_iter(term: &Rc<Term>) -> ListTermIterator {
    method as_inproper_list (line 600) | pub fn as_inproper_list(term: &Rc<Term>) -> (Vec<Rc<Term>>, Rc<Term>) {
    method as_list (line 611) | pub fn as_list(term: &Rc<Term>) -> Option<Vec<Rc<Term>>> {
    method as_value_list (line 620) | pub fn as_value_list(term: &Rc<Term>) -> Vec<Rc<Term>> {
    method to_doc (line 627) | pub fn to_doc(_term: Rc<Term>) -> pretty::Doc<'static, pretty::BoxDoc<...
  method eq (line 183) | fn eq(&self, other: &Self) -> bool {
  method cmp (line 256) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 261) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method hash (line 344) | fn hash<H: Hasher>(&self, state: &mut H) {
  type ListIteratorItem (line 393) | pub enum ListIteratorItem {
  type ListTermIterator (line 398) | pub struct ListTermIterator {
  type Item (line 402) | type Item = ListIteratorItem;
  method next (line 403) | fn next(&mut self) -> Option<ListIteratorItem> {
  type ErlEq (line 746) | pub trait ErlEq<Rhs = Self> {
    method erl_eq (line 747) | fn erl_eq(&self, other: &Rhs) -> bool;
    method erl_eq (line 759) | fn erl_eq(&self, other: &f64) -> bool {
    method erl_eq (line 765) | fn erl_eq(&self, other: &Term) -> bool {
  type ErlExactEq (line 750) | pub trait ErlExactEq<Rhs = Self> {
    method erl_exact_eq (line 751) | fn erl_exact_eq(&self, other: &Rhs) -> bool;
    method erl_exact_eq (line 836) | fn erl_exact_eq(&self, other: &Term) -> bool {
  type ErlOrd (line 754) | pub trait ErlOrd<Rhs = Self> {
    method erl_ord (line 755) | fn erl_ord(&self, other: &Rhs) -> ::std::cmp::Ordering;
    method erl_ord (line 842) | fn erl_ord(&self, other: &Term) -> ::std::cmp::Ordering {

FILE: libeir_interpreter/src/trace/dummy.rs
  function set_pid (line 8) | pub fn set_pid(_pid: Pid) {}
  function enter_function (line 9) | pub fn enter_function(_ident: &FunctionIdent, _lambda: Option<Block>, _a...
  function warning (line 13) | pub fn warning(_text: String) {}
  function warning_args (line 14) | pub fn warning_args<F>(_text: String, _make_args: F) where F: FnOnce() -...

FILE: libeir_interpreter/src/trace/trace.rs
  type TraceEntry (line 16) | enum TraceEntry {
  function gen_vm_id (line 59) | pub fn gen_vm_id() {
  function vm_id (line 67) | fn vm_id() -> usize {
  type StackEntry (line 73) | struct StackEntry {
  type TraceEvent (line 80) | struct TraceEvent {
  type TraceEventType (line 85) | enum TraceEventType {
  type TraceCollector (line 107) | struct TraceCollector {
    method new (line 115) | fn new() -> Self {
  function set_pid (line 125) | pub fn set_pid(pid: Pid) {
  function get_pid (line 132) | pub fn get_pid() -> Pid {
  function enter_function (line 139) | pub fn enter_function(ident: &FunctionIdent, lambda: Option<Block>, args...
  function exit_function (line 165) | pub fn exit_function(ident: &FunctionIdent, ret: Option<&CallReturn>) {
  function start_basic_block (line 184) | pub fn start_basic_block(module: &Atom, ident: &FunctionIdent, block: La...
  function end_basic_block (line 199) | pub fn end_basic_block() {
  function warning (line 210) | pub fn warning(text: String) {
  function warning_args (line 224) | pub fn warning_args<F>(text: String, make_args: F) where F: FnOnce() -> ...
  function dump_trace (line 238) | pub fn dump_trace(filename: String) {

FILE: libeir_interpreter/src/vm.rs
  type WatchType (line 13) | pub enum WatchType {
  type ReferenceGenerator (line 19) | pub struct ReferenceGenerator(Reference);
    method new (line 21) | fn new() -> Self {
    method next (line 25) | pub fn next(&mut self) -> Reference {
  type VMState (line 32) | pub struct VMState {
    method new (line 44) | pub fn new() -> Self {
    method add_erlang_module (line 54) | pub fn add_erlang_module(&mut self, module: Module) {
    method add_native_module (line 69) | pub fn add_native_module(&mut self, module: NativeModule) {
    method add_nif_overlay (line 82) | pub fn add_nif_overlay(&mut self, module: NativeModule) {
    method add_builtin_modules (line 92) | pub fn add_builtin_modules(&mut self) {
    method call (line 99) | pub fn call(

FILE: libeir_ir/build.rs
  function main (line 3) | fn main() {

FILE: libeir_ir/src/algo/equality.rs
  type EqualityFail (line 10) | pub enum EqualityFail {
  type EqCtx (line 52) | struct EqCtx<'a> {
  type GraphEqOptions (line 61) | pub struct GraphEqOptions {
  method default (line 66) | fn default() -> Self {
  method graph_eq_opts (line 74) | pub fn graph_eq_opts(
  method graph_eq (line 179) | pub fn graph_eq(
  function traverse_value (line 189) | fn traverse_value<'a>(ctx: &mut EqCtx<'a>, l: Value, r: Value) -> Result...
  function basic_equality (line 240) | fn basic_equality() {
  function args_length_inequality (line 273) | fn args_length_inequality() {
  function args_read_inequality (line 298) | fn args_read_inequality() {
  function args_read_const_equality (line 323) | fn args_read_const_equality() {
  function args_read_const_inequality (line 348) | fn args_read_const_inequality() {
  function args_prim_inequality (line 373) | fn args_prim_inequality() {
  function block_location_equality (line 400) | fn block_location_equality() {

FILE: libeir_ir/src/algo/func_tree.rs
  type FunctionTree (line 10) | pub struct FunctionTree {
    method validate_no_cycles (line 231) | fn validate_no_cycles(&self, entry: Block, mut curr: usize, limit: usi...
    method dfs (line 241) | pub fn dfs(&self) -> Dfs<Block, EntityVisitMap<Block>> {
    method dfs_iter (line 244) | pub fn dfs_iter<'a>(&'a self) -> impl Iterator<Item = Block> + 'a {
    method dfs_post_order (line 248) | pub fn dfs_post_order(&self) -> DfsPostOrder<Block, EntityVisitMap<Blo...
    method dfs_post_order_iter (line 251) | pub fn dfs_post_order_iter<'a>(&'a self) -> impl Iterator<Item = Block...
  type FunctionEntry (line 22) | pub struct FunctionEntry {
  type Escape (line 55) | enum Escape {
  method func_tree (line 61) | pub fn func_tree(&self, live: &LiveValues, resolve_continuations: bool) ...
  type NodeId (line 257) | type NodeId = Block;
  type EdgeId (line 258) | type EdgeId = (Block, Block);
  type Neighbors (line 262) | type Neighbors = std::iter::Cloned<std::collections::btree_set::Iter<'a,...
  method neighbors (line 263) | fn neighbors(self, block: Block) -> Self::Neighbors {
  type Map (line 269) | type Map = EntityVisitMap<Block>;
  method visit_map (line 270) | fn visit_map(&self) -> EntityVisitMap<Block> {
  method reset_map (line 273) | fn reset_map(&self, map: &mut EntityVisitMap<Block>) {

FILE: libeir_ir/src/algo/live.rs
  method live_values (line 10) | pub fn live_values(&self) -> LiveValues {
  type LiveValues (line 27) | pub struct LiveValues {
    method get_aux (line 39) | fn get_aux(&self) -> &SetForest<Value> {
    method aux_fmt (line 45) | fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, _aux: &C) -> std::f...
    method fmt (line 54) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    method live_at (line 60) | pub fn live_at<'a>(&'a self, block: Block) -> BoundSet<'a, Value, ()> {
    method live_in (line 63) | pub fn live_in<'a>(&'a self, block: Block) -> BoundSet<'a, Value, ()> {
    method is_live_at (line 67) | pub fn is_live_at(&self, block: Block, value: Value) -> bool {
    method is_live_in (line 70) | pub fn is_live_in(&self, block: Block, value: Value) -> bool {
  function dataflow_pass (line 75) | fn dataflow_pass(
  function calculate_live_values (line 138) | pub fn calculate_live_values(fun: &Function) -> LiveValues {
  function test_simple (line 173) | fn test_simple() {
  function test_cycle (line 208) | fn test_cycle() {

FILE: libeir_ir/src/algo/mangle/datatypes.rs
  type FromT (line 8) | pub struct FromT<T>(pub T);
  function map_fun (line 10) | pub(super) fn map_fun<'a, 'b, R, F, V>(self, recv: &'a R, mut f: F) -> F...
  function inner (line 20) | pub fn inner(self) -> T {
  function from (line 25) | fn from(f: T) -> Self {
  function fmt (line 33) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type FromValue (line 37) | pub(super) type FromValue = FromT<Value>;
  type FromBlock (line 38) | pub(super) type FromBlock = FromT<Block>;
  type ToT (line 41) | pub struct ToT<T>(pub T);
  function map_fun (line 43) | pub(super) fn map_fun<'a, 'b, R, F, V>(self, recv: &'a R, mut f: F) -> T...
  function inner (line 53) | pub fn inner(self) -> T {
  function from (line 58) | fn from(f: T) -> Self {
  function fmt (line 66) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type ToValue (line 70) | pub type ToValue = ToT<Value>;
  type ToBlock (line 71) | pub type ToBlock = ToT<Block>;
  type MangleTarget (line 77) | pub enum MangleTarget<T> {
  function fmt (line 85) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  function inner (line 90) | pub fn inner(self) -> T {
  function inner_ref (line 96) | pub fn inner_ref(&self) -> &T {
  function fun (line 103) | pub(super) fn fun<'a, 'b, R>(&self, recv: &'a R) -> &'a Function
  function map (line 113) | pub fn map<F, V>(self, mut f: F) -> MangleTarget<V>
  function map_fun (line 129) | pub(super) fn map_fun<'a, 'b, R, F, V>(self, recv: &'a R, mut f: F) -> M...
  function new_with (line 147) | pub fn new_with<N>(&self, new: N) -> MangleTarget<N> {
  function from (line 154) | pub fn from(self) -> Option<FromT<T>> {
  function to (line 160) | pub fn to(self) -> Option<ToT<T>> {
  function transpose_opt (line 168) | pub fn transpose_opt(self) -> Option<MangleTarget<I>> {
  function cloned (line 181) | pub fn cloned(&self) -> MangleTarget<T> {
  function transpose_iter (line 189) | pub fn transpose_iter(self) -> impl Iterator<Item = MangleTarget<V>> {
  function from (line 208) | fn from(i: FromT<I>) -> MangleTarget<I> {
  function from (line 213) | fn from(i: ToT<I>) -> MangleTarget<I> {
  type MangleValue (line 217) | pub(super) type MangleValue = MangleTarget<Value>;
  type MangleBlock (line 218) | pub(super) type MangleBlock = MangleTarget<Block>;

FILE: libeir_ir/src/algo/mangle/mod.rs
  type Mangler (line 29) | pub struct Mangler {
    method new (line 49) | pub fn new() -> Self {
    method clear (line 70) | fn clear(&mut self) {
    method value_map (line 87) | pub fn value_map<'a>(&'a self) -> &'a BTreeMap<MangleValue, (MangleVal...
    method start (line 93) | pub fn start<F>(&mut self, from_block: F)
    method add_rename (line 101) | pub fn add_rename<O, N>(&mut self, old: O, new: N)
    method add_rename_nofollow (line 114) | pub fn add_rename_nofollow<O, N>(&mut self, old: O, new: N)
    method run (line 123) | pub fn run(&mut self, fun: &mut FunctionBuilder) -> Block {
    method run_across (line 129) | pub fn run_across(&mut self, from: &Function, to: &mut FunctionBuilder...
    method propagate_values (line 134) | fn propagate_values(&mut self) {
    method run_inner (line 155) | fn run_inner<'a, 'b, R>(&mut self, recv: &'a mut R) -> Block
    method map (line 359) | fn map<'a, 'b, R>(&mut self, bump: &Bump, recv: &'a mut R, mut val: Ma...

FILE: libeir_ir/src/algo/mangle/receiver.rs
  type MangleReceiver (line 10) | pub(super) trait MangleReceiver<'b> {
    method from (line 16) | fn from<'a>(&'a self) -> &'a Function;
    method to (line 19) | fn to<'a>(&'a mut self) -> &'a mut FunctionBuilder<'b>;
    method to_fun (line 20) | fn to_fun<'a>(&'a self) -> &'a Function;
    method map_const (line 25) | fn map_const(&mut self, val: MangleValue) -> ToValue;
    method map_free_value (line 30) | fn map_free_value(&mut self, val: MangleValue) -> ToValue;
    method map_block_op (line 34) | fn map_block_op(&mut self, block: MangleBlock) -> OpKind;
  type SingleMangleReceiver (line 38) | pub(super) struct SingleMangleReceiver<'a, 'b> {
  function from (line 42) | fn from<'a>(&'a self) -> &'a Function {
  function to (line 47) | fn to<'a>(&'a mut self) -> &'a mut FunctionBuilder<'b> {
  function to_fun (line 50) | fn to_fun<'a>(&'a self) -> &'a Function {
  function map_const (line 53) | fn map_const(&mut self, val: MangleValue) -> ToValue {
  function map_free_value (line 56) | fn map_free_value(&mut self, val: MangleValue) -> ToValue {
  function map_block_op (line 59) | fn map_block_op(&mut self, block: MangleBlock) -> OpKind {
  type CopyMangleReceiver (line 67) | pub(super) struct CopyMangleReceiver<'a, 'b> {
  function from (line 72) | fn from<'a>(&'a self) -> &'a Function {
  function to (line 75) | fn to<'a>(&'a mut self) -> &'a mut FunctionBuilder<'b> {
  function to_fun (line 78) | fn to_fun<'a>(&'a self) -> &'a Function {
  function map_const (line 81) | fn map_const(&mut self, _val: MangleValue) -> ToValue {
  function map_free_value (line 84) | fn map_free_value(&mut self, _val: MangleValue) -> ToValue {
  function map_block_op (line 87) | fn map_block_op(&mut self, _block: MangleBlock) -> OpKind {

FILE: libeir_ir/src/algo/mangle/tests.rs
  function simple_mangle (line 7) | fn simple_mangle() {
  function preserves_block_locations (line 56) | fn preserves_block_locations() {
  function mangle_primop (line 96) | fn mangle_primop() {
  function mangle_recursive (line 134) | fn mangle_recursive() {
  function mangle_entry (line 191) | fn mangle_entry() {

FILE: libeir_ir/src/algo/op_branches.rs
  type BranchIter (line 4) | pub struct BranchIter<'a> {
  type Item (line 11) | type Item = Value;
  method next (line 12) | fn next(&mut self) -> Option<Value> {
  method op_branch_iter (line 38) | pub fn op_branch_iter<'a>(&'a self, block: Block) -> BranchIter<'a> {
  method op_branch_len (line 47) | pub fn op_branch_len(&self, block: Block) -> Option<usize> {
  method op_branch_target (line 79) | pub fn op_branch_target(&self, block: Block, n: usize) -> Value {

FILE: libeir_ir/src/algo/validate.rs
  type FnvHashMap (line 5) | type FnvHashMap<K, V> = HashMap<K, V, FnvBuildHasher>;
  type ValidationError (line 15) | pub enum ValidationError {
  function get_value_list (line 50) | fn get_value_list<'a>(fun: &'a Function, value: Value) -> Option<&'a [Va...
  method validate (line 61) | pub fn validate(&self, errors: &mut Vec<ValidationError>) {
  method validate_call_to (line 73) | fn validate_call_to(
  method validate_blocks (line 93) | fn validate_blocks(&self, errors: &mut Vec<ValidationError>) {
  method validate_entry_invariants (line 184) | fn validate_entry_invariants(&self, errors: &mut Vec<ValidationError>) {
  method validate_ssa_visibility (line 212) | fn validate_ssa_visibility(&self, doms: &Dominators<Block>, errors: &mut...
  method insert_live_for_node (line 272) | fn insert_live_for_node(

FILE: libeir_ir/src/binary.rs
  type Endianness (line 5) | pub enum Endianness {
  type BinaryEntrySpecifier (line 12) | pub enum BinaryEntrySpecifier {
    method has_size (line 38) | pub fn has_size(&self) -> bool {
    method is_native_endian (line 46) | pub fn is_native_endian(&self) -> bool {
  method default (line 70) | fn default() -> Self {

FILE: libeir_ir/src/constant/atomic.rs
  type BigIntTerm (line 22) | pub struct BigIntTerm(pub BigInt);
    method value (line 25) | pub fn value(&self) -> &BigInt {
    method into (line 31) | fn into(self) -> BigInt {
  method fmt (line 46) | fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
  type IntTerm (line 52) | pub struct IntTerm(pub i64);
    method value (line 55) | pub fn value(&self) -> i64 {
    method into (line 61) | fn into(self) -> i64 {
  method fmt (line 71) | fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
  function from_num (line 76) | fn from_num<N>(n: N) -> AtomicTerm
  type FloatTerm (line 109) | pub struct FloatTerm(pub Float);
    method value (line 112) | pub fn value(&self) -> f64 {
  method hash (line 119) | fn hash<H>(&self, state: &mut H)
  method fmt (line 150) | fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
  type AtomTerm (line 156) | pub struct AtomTerm(pub Symbol);
    method eq (line 179) | fn eq(&self, other: &str) -> bool {
  method fmt (line 184) | fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
  type BinaryTerm (line 190) | pub struct BinaryTerm(pub BitVec);
    method value (line 193) | pub fn value(&self) -> &BitVec {
  type NilTerm (line 214) | pub struct NilTerm;
  type AtomicTerm (line 222) | pub enum AtomicTerm {
    method from (line 13) | fn from(int: Integer) -> AtomicTerm {
    method from (line 36) | fn from(data: BigIntTerm) -> Self {
    method from (line 41) | fn from(data: BigInt) -> Self {
    method from (line 66) | fn from(data: IntTerm) -> Self {
    method from (line 103) | fn from(data: char) -> Self {
    method from (line 127) | fn from(data: FloatTerm) -> Self {
    method from (line 132) | fn from(data: f64) -> Self {
    method from (line 137) | fn from(data: Float) -> Self {
    method from (line 142) | fn from(data: Number) -> Self {
    method from (line 158) | fn from(data: AtomTerm) -> Self {
    method from (line 163) | fn from(data: Symbol) -> Self {
    method from (line 168) | fn from(data: bool) -> Self {
    method from (line 198) | fn from(data: BinaryTerm) -> Self {
    method from (line 203) | fn from(data: Vec<u8>) -> Self {
    method from (line 208) | fn from(data: BitVec) -> Self {
    method from (line 216) | fn from(_data: NilTerm) -> Self {
  method fmt (line 232) | fn fmt(&self, fmt: &mut Formatter) -> FmtResult {

FILE: libeir_ir/src/constant/float.rs
  constant SIGN_MASK (line 6) | const SIGN_MASK: u64 = 0x8000_0000_0000_0000u64;
  constant EXP_MASK (line 7) | const EXP_MASK: u64 = 0x7ff0_0000_0000_0000u64;
  constant MAN_MASK (line 8) | const MAN_MASK: u64 = 0x000f_ffff_ffff_ffffu64;
  constant CANONICAL_NAN_BITS (line 11) | const CANONICAL_NAN_BITS: u64 = 0x7ff8_0000_0000_0000u64;
  constant CANONICAL_ZERO_BITS (line 12) | const CANONICAL_ZERO_BITS: u64 = 0x0u64;
  function raw_double_bits (line 15) | pub fn raw_double_bits<F: Float>(f: &F) -> u64 {

FILE: libeir_ir/src/constant/mod.rs
  type Const (line 18) | pub struct Const(u32);
  type ConstKind (line 22) | pub enum ConstKind {
    method aux_hash (line 38) | fn aux_hash<H: Hasher>(&self, state: &mut H, container: &ListPool<Cons...
    method aux_eq (line 62) | fn aux_eq(
    method is_map (line 96) | pub fn is_map(&self) -> bool {
  type ConstantContainer (line 105) | pub struct ConstantContainer {
    method new (line 122) | pub fn new() -> Self {
    method const_kind (line 126) | pub fn const_kind(&self, value: Const) -> &ConstKind {
    method list_cell (line 130) | pub fn list_cell(&mut self, head: Const, tail: Const) -> Const {
    method nil (line 134) | pub fn nil(&mut self) -> Const {
    method from (line 138) | pub fn from<T>(&mut self, val: T) -> Const
    method get (line 145) | pub fn get<T>(&self, val: T) -> Option<Const>
    method as_bool (line 163) | pub fn as_bool(&self, val: Const) -> Option<bool> {
    method write (line 172) | pub fn write(&self, val: Const, out: &mut dyn std::io::Write) {
    method tuple_builder (line 214) | pub fn tuple_builder(&self) -> TupleBuilder {
    method eq_other (line 218) | pub fn eq_other(&self, l: Const, r_cont: &ConstantContainer, r: Const)...
  method default (line 112) | fn default() -> Self {
  type IntoConst (line 240) | pub trait IntoConst {
    method into_const (line 241) | fn into_const(self, c: &mut ConstantContainer) -> Const;
    method get_const (line 242) | fn get_const(self, fun: &ConstantContainer) -> Option<Const>;
    method into_const (line 247) | fn into_const(self, c: &mut ConstantContainer) -> Const {
    method get_const (line 253) | fn get_const(self, c: &ConstantContainer) -> Option<Const> {
    method into_const (line 265) | fn into_const(self, c: &mut ConstantContainer) -> Const {
    method get_const (line 268) | fn get_const(self, c: &ConstantContainer) -> Option<Const> {
    method into_const (line 274) | fn into_const(self, c: &mut ConstantContainer) -> Const {
    method get_const (line 283) | fn get_const(self, c: &ConstantContainer) -> Option<Const> {
    method into_const (line 289) | fn into_const(self, _c: &mut ConstantContainer) -> Const {
    method get_const (line 292) | fn get_const(self, _c: &ConstantContainer) -> Option<Const> {
    method into_const (line 298) | fn into_const(self, c: &mut ConstantContainer) -> Const {
    method get_const (line 301) | fn get_const(self, c: &ConstantContainer) -> Option<Const> {
  type EmptyMap (line 245) | pub struct EmptyMap;
  type TupleBuilder (line 306) | pub struct TupleBuilder {
    method new (line 310) | pub fn new() -> Self {
    method push (line 316) | pub fn push(&mut self, elem: Const, c: &mut ConstantContainer) {
    method clear (line 320) | pub fn clear(mut self, c: &mut ConstantContainer) {
    method finish (line 324) | pub fn finish(self, c: &mut ConstantContainer) -> Const {

FILE: libeir_ir/src/dialect/mod.rs
  type ArcDialect (line 23) | pub type ArcDialect = Arc<Dialect>;
  type Dialect (line 27) | pub struct Dialect {
    method new (line 43) | pub fn new() -> Self {
    method contains_op (line 52) | pub fn contains_op<T: Op>(&self) -> bool {
    method register_op (line 56) | pub fn register_op<T: Op>(&mut self) {
    method register_op_branches_impl (line 60) | pub fn register_op_branches_impl<T: MetaEntry + OpBranches>(&mut self) {
    method get_op_branches (line 65) | pub fn get_op_branches<'a>(&self, obj: &'a dyn Op) -> Option<&'a dyn O...
    method register_op_printer_impl (line 69) | pub fn register_op_printer_impl<T: MetaEntry + OpPrinter>(&mut self) {
    method get_op_printer (line 74) | pub fn get_op_printer<'a>(&self, obj: &'a dyn Op) -> Option<&'a dyn Op...
    method register_op_parser (line 78) | pub fn register_op_parser(&mut self, sym: Symbol, parser: Box<dyn OpPa...
    method get_op_parser (line 82) | pub fn get_op_parser(&self, sym: Symbol) -> Option<&dyn OpParser> {
  method fmt (line 37) | fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {

FILE: libeir_ir/src/function/builder/mod.rs
  method builder (line 17) | pub fn builder(&mut self) -> FunctionBuilder<'_> {
  type IntoValue (line 22) | pub trait IntoValue {
    method into_value (line 23) | fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value;
    method get_value (line 24) | fn get_value(self, fun: &Function) -> Option<Value>;
    method into_value (line 27) | fn into_value<'a>(self, _b: &mut FunctionBuilder<'a>) -> Value {
    method get_value (line 30) | fn get_value(self, _fun: &Function) -> Option<Value> {
    method into_value (line 35) | fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {
    method get_value (line 38) | fn get_value(self, fun: &Function) -> Option<Value> {
    method into_value (line 43) | fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {
    method get_value (line 46) | fn get_value(self, fun: &Function) -> Option<Value> {
    method into_value (line 54) | fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {
    method get_value (line 60) | fn get_value(self, fun: &Function) -> Option<Value> {
    method into_value (line 93) | fn into_value<'a>(self, b: &mut FunctionBuilder<'a>) -> Value {
    method get_value (line 101) | fn get_value(self, fun: &Function) -> Option<Value> {
  type DynValue (line 66) | pub enum DynValue {
  method into (line 73) | fn into(self) -> DynValue {
  method into (line 78) | fn into(self) -> DynValue {
  method into (line 83) | fn into(self) -> DynValue {
  method into (line 88) | fn into(self) -> DynValue {
  type FunctionBuilder (line 111) | pub struct FunctionBuilder<'a> {
  function new (line 122) | pub fn new(fun: &'a mut Function) -> FunctionBuilder<'a> {
  function fun (line 135) | pub fn fun(&self) -> &Function {
  function fun_mut (line 138) | pub fn fun_mut(&mut self) -> &mut Function {
  function cons (line 142) | pub fn cons(&self) -> &ConstantContainer {
  function cons_mut (line 145) | pub fn cons_mut(&mut self) -> &mut ConstantContainer {
  function value (line 152) | pub fn value<T>(&mut self, v: T) -> Value
  function value_map (line 159) | pub fn value_map<F>(&mut self, mut value: Value, map: &mut F) -> Value
  function graph_update_block (line 193) | pub(crate) fn graph_update_block(&mut self, block: Block) {
  function block_insert (line 261) | pub fn block_insert(&mut self) -> Block {
  function block_insert_with_span (line 265) | pub fn block_insert_with_span(&mut self, span: Option<SourceSpan>) -> Bl...
  function block_insert_get_val (line 270) | pub fn block_insert_get_val(&mut self) -> (Block, Value) {
  function block_arg_insert (line 276) | pub fn block_arg_insert(&mut self, block: Block) -> Value {
  function block_args (line 280) | pub fn block_args(&self, block: Block) -> &[Value] {
  function block_reads (line 284) | pub fn block_reads(&self, block: Block) -> &[Value] {
  function block_set_entry (line 288) | pub fn block_set_entry(&mut self, block: Block) {
  function block_set_location (line 292) | pub fn block_set_location(&mut self, block: Block, loc: Location) {
  function block_clear_take (line 296) | pub fn block_clear_take(&mut self, block: Block) -> Option<OpKind> {
  function block_clear (line 336) | pub fn block_clear(&mut self, block: Block) {
  function block_value_map (line 340) | pub fn block_value_map<F>(&mut self, block: Block, mut map: F)
  function block_copy_body_map (line 356) | pub fn block_copy_body_map<F>(&mut self, from: Block, to: Block, mut map...
  function graph_impl (line 396) | fn graph_impl() {

FILE: libeir_ir/src/function/builder/op.rs
  function op_call_flow (line 14) | pub fn op_call_flow<'b, V>(&'b mut self, block: Block, target: V, args: ...
  function op_call_function_next (line 32) | pub fn op_call_function_next<'b, V>(
  function op_call_function (line 58) | pub fn op_call_function<'b, V>(
  function op_trace_capture_raw_next (line 80) | pub fn op_trace_capture_raw_next(&mut self, span: SourceSpan, block: Blo...
  function op_trace_capture_raw (line 90) | pub fn op_trace_capture_raw(&mut self, span: SourceSpan, block: Block) -...
  function op_intrinsic (line 100) | pub fn op_intrinsic<'b, O: OpBuild>(
  function op_map_put_build (line 121) | pub fn op_map_put_build(&mut self, span: SourceSpan, value: Value) -> Ma...
  function op_unpack_value_list_next (line 125) | pub fn op_unpack_value_list_next(
  function op_unpack_value_list (line 142) | pub fn op_unpack_value_list(&mut self, block: Block, list: Value, num: u...
  function op_if_bool_next (line 152) | pub fn op_if_bool_next(
  function op_if_bool (line 173) | pub fn op_if_bool(
  function op_if_bool_strict_next (line 198) | pub fn op_if_bool_strict_next(
  function op_if_bool_strict (line 217) | pub fn op_if_bool_strict(
  function op_unreachable (line 233) | pub fn op_unreachable(&mut self, span: SourceSpan, block: Block) {
  function op_match_build (line 243) | pub fn op_match_build(&mut self, span: SourceSpan) -> MatchBuilder {
  type MatchBuilder (line 248) | pub struct MatchBuilder {
    method new (line 267) | pub fn new(span: SourceSpan) -> Self {
    method push_value_next (line 273) | pub fn push_value_next(&mut self, next: Value, val: Value, b: &mut Fun...
    method push_value (line 281) | pub fn push_value(&mut self, val: Value, b: &mut FunctionBuilder) -> B...
    method push_type_next (line 287) | pub fn push_type_next(&mut self, next: Value, typ: BasicType, b: &mut ...
    method push_type (line 295) | pub fn push_type(&mut self, typ: BasicType, b: &mut FunctionBuilder) -...
    method push_tuple_next (line 301) | pub fn push_tuple_next(&mut self, next: Value, arity: usize, b: &mut F...
    method push_tuple (line 309) | pub fn push_tuple(&mut self, arity: usize, b: &mut FunctionBuilder) ->...
    method push_binary (line 320) | pub fn push_binary(
    method push_list_cell_next (line 344) | pub fn push_list_cell_next(&mut self, next: Value, b: &mut FunctionBui...
    method push_list_cell (line 352) | pub fn push_list_cell(&mut self, b: &mut FunctionBuilder) -> Block {
    method push_map_item_next (line 362) | pub fn push_map_item_next(&mut self, next: Value, key: Value, b: &mut ...
    method push_map_item (line 370) | pub fn push_map_item(&mut self, key: Value, b: &mut FunctionBuilder) -...
    method push_wildcard_next (line 379) | pub fn push_wildcard_next(&mut self, next: Value, b: &mut FunctionBuil...
    method push_wildcard (line 387) | pub fn push_wildcard(&mut self, span: SourceSpan, b: &mut FunctionBuil...
    method finish (line 396) | pub fn finish(self, block: Block, value: Value, b: &mut FunctionBuilde...
  method default (line 256) | fn default() -> Self {
  type MapPutBuilder (line 423) | pub struct MapPutBuilder {
    method new (line 431) | pub fn new(span: SourceSpan, value: Value, b: &mut FunctionBuilder) ->...
    method push_kv (line 453) | pub fn push_kv(
    method finish (line 466) | pub fn finish(self, block: Block, b: &mut FunctionBuilder) -> (Block, ...

FILE: libeir_ir/src/function/builder/primop.rs
  function prim_binop (line 10) | pub fn prim_binop(&mut self, span: SourceSpan, op: BinOp, lhs: Value, rh...
  function prim_tuple (line 34) | pub fn prim_tuple(&mut self, span: SourceSpan, values: &[Value]) -> Value {
  function prim_map (line 67) | pub fn prim_map(&mut self, span: SourceSpan, keys: &[Value], values: &[V...
  function prim_list_cell (line 137) | pub fn prim_list_cell(&mut self, span: SourceSpan, head: Value, tail: Va...
  function prim_value_list (line 165) | pub fn prim_value_list(&mut self, values: &[Value]) -> Value {
  function prim_value_list_from_entity_list (line 188) | pub(crate) fn prim_value_list_from_entity_list(&mut self, values: Entity...
  function prim_logic_op (line 212) | pub fn prim_logic_op(&mut self, span: SourceSpan, op: LogicOp, values: &...
  function prim_capture_function (line 269) | pub fn prim_capture_function<M, F, A>(&mut self, span: SourceSpan, m: M,...
  function prim_from_kind (line 297) | pub fn prim_from_kind(&mut self, span: SourceSpan, op: PrimOpKind, vals:...

FILE: libeir_ir/src/function/format.rs
  type ContainerDebug (line 16) | pub trait ContainerDebug<C>: Debug {
    method fmt (line 17) | fn fmt(&self, container: &C, f: &mut Formatter) -> Result;
  type ContainerDebugAdapter (line 20) | pub struct ContainerDebugAdapter<'a, C, V> {
  method fmt (line 28) | fn fmt(&self, f: &mut Formatter) -> Result {
  method fmt (line 34) | fn fmt(&self, _con: &C, f: &mut Formatter) -> Result {
  method fmt (line 40) | fn fmt(&self, fun: &Function, f: &mut Formatter) -> Result {
  function fmt (line 51) | fn fmt(&self, fun: &Function, f: &mut Formatter) -> Result {
  function fmt (line 69) | fn fmt(&self, con: &C, f: &mut Formatter) -> Result {
  function fmt (line 92) | fn fmt(&self, con: &C, f: &mut Formatter) -> Result {
  function fmt (line 115) | fn fmt(&self, con: &C, f: &mut Formatter) -> Result {
  function fmt (line 129) | fn fmt(&self, con: &C, f: &mut Formatter) -> Result {
  function fmt (line 141) | fn fmt(&self, _con: &C, f: &mut Formatter) -> Result {

FILE: libeir_ir/src/function/location.rs
  type Location (line 13) | pub struct Location(u32);
  type LocationTerminal (line 17) | pub struct LocationTerminal(u32);
  type LocationTerminalData (line 21) | struct LocationTerminalData {
    method aux_hash (line 41) | fn aux_hash<H: Hasher>(&self, state: &mut H, _container: &()) {
    method aux_eq (line 46) | fn aux_eq(&self, rhs: &Self, _self_aux: &(), _rhs_aux: &()) -> bool {
  type LocationData (line 52) | struct LocationData {
    method aux_hash (line 56) | fn aux_hash<H: Hasher>(&self, state: &mut H, container: &ListPool<Loca...
    method aux_eq (line 61) | fn aux_eq(
  type LocationContainer (line 72) | pub struct LocationContainer {
    method new (line 80) | pub fn new() -> Self {
    method lookup (line 92) | pub fn lookup(&self, location: &Location) -> Vec<SourceSpan> {
    method location_empty (line 104) | pub fn location_empty(&mut self) -> Location {
    method location_unknown (line 113) | pub fn location_unknown(&mut self) -> Location {
    method terminal (line 136) | pub fn terminal(
    method location (line 156) | pub fn location(
    method terminal_from_bytespan (line 173) | pub fn terminal_from_bytespan(
    method from_bytespan (line 193) | pub fn from_bytespan(
    method from_terminals (line 209) | pub fn from_terminals(&mut self, terminals: &[LocationTerminal]) -> Lo...
    method concat_locations (line 221) | pub fn concat_locations(&mut self, bottom: Location, top: Location) ->...
    method location_eq (line 249) | pub fn location_eq(&self, l_loc: Location, r: &Self, r_loc: Location) ...
    method format_loc (line 276) | pub fn format_loc(&self, loc: Location) -> String {

FILE: libeir_ir/src/function/mod.rs
  type Block (line 43) | pub struct Block(u32);
    method aux_fmt (line 51) | fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, _aux: &C) -> std::f...
  method default (line 46) | fn default() -> Self {
  type Argument (line 57) | pub struct Argument(u32);
  type FunRef (line 62) | pub struct FunRef(u32);
  type PrimOp (line 66) | pub struct PrimOp(u32);
  type BlockData (line 70) | pub struct BlockData {
  type PrimOpData (line 87) | pub struct PrimOpData {
    method aux_hash (line 92) | fn aux_hash<H: Hasher>(&self, state: &mut H, container: &PoolContainer) {
    method aux_eq (line 98) | fn aux_eq(
  type AttributeKey (line 112) | pub enum AttributeKey {
  type AttributeValue (line 116) | pub enum AttributeValue {
  type Function (line 121) | pub struct Function {
    method dialect (line 143) | pub fn dialect(&self) -> &ArcDialect {
    method span (line 147) | pub fn span(&self) -> SourceSpan {
    method cons (line 151) | pub fn cons(&self) -> &ConstantContainer {
    method get_aux (line 157) | fn get_aux(&self) -> &ListPool<Value> {
    method get_aux (line 162) | fn get_aux(&self) -> &SetForest<Block> {
    method aux_fmt (line 168) | fn aux_fmt(&self, _f: &mut std::fmt::Formatter<'_>, _container: &C) ->...
    method fmt (line 174) | fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
    method value_get (line 181) | pub fn value_get<T>(&self, v: T) -> Option<Value>
    method iter_constants (line 188) | pub fn iter_constants(&self) -> std::collections::hash_set::Iter<'_, V...
    method const_kind (line 192) | pub fn const_kind(&self, constant: Const) -> &ConstKind {
    method const_entries (line 196) | pub fn const_entries<'f>(&'f self, entries: &'f EntityList<Const>) -> ...
    method value_kind (line 200) | pub fn value_kind(&self, value: Value) -> ValueKind {
    method value_locations (line 204) | pub fn value_locations(&self, value: Value) -> Option<Vec<SourceSpan>> {
    method value_is_constant (line 211) | pub fn value_is_constant(&self, value: Value) -> bool {
    method value_list_length (line 215) | pub fn value_list_length(&self, value: Value) -> usize {
    method value_list_get_n (line 227) | pub fn value_list_get_n(&self, value: Value, n: usize) -> Option<Value> {
    method value_argument (line 246) | pub fn value_argument(&self, value: Value) -> Option<(Block, usize)> {
    method value_block (line 254) | pub fn value_block(&self, value: Value) -> Option<Block> {
    method value_const (line 262) | pub fn value_const(&self, value: Value) -> Option<Const> {
    method value_primop (line 270) | pub fn value_primop(&self, value: Value) -> Option<PrimOp> {
    method value_usages (line 278) | pub fn value_usages(&self, value: Value) -> BoundSet<Block, ()> {
    method value_walk_nested_values (line 284) | pub fn value_walk_nested_values<F, R>(&self, value: Value, visit: &mut...
    method value_walk_nested_values_mut (line 294) | pub fn value_walk_nested_values_mut<F, R>(
    method primop_kind (line 312) | pub fn primop_kind(&self, primop: PrimOp) -> &PrimOpKind {
    method primop_reads (line 315) | pub fn primop_reads(&self, primop: PrimOp) -> &[Value] {
    method primop_walk_nested_values (line 319) | pub fn primop_walk_nested_values<F, R>(&self, primop: PrimOp, visit: &...
    method primop_walk_nested_values_mut (line 330) | pub fn primop_walk_nested_values_mut<F, R>(
    method block_insert (line 350) | fn block_insert(&mut self) -> Block {
    method block_insert_with_span (line 354) | fn block_insert_with_span(&mut self, span: Option<SourceSpan>) -> Block {
    method block_arg_insert (line 373) | fn block_arg_insert(&mut self, block: Block) -> Value {
    method block_arg_n (line 380) | pub fn block_arg_n(&self, block: Block, num: usize) -> Option<Value> {
    method block_kind (line 384) | pub fn block_kind(&self, block: Block) -> Option<&OpKind> {
    method block_location (line 388) | pub fn block_location(&self, block: Block) -> Location {
    method block_locations (line 392) | pub fn block_locations(&self, block: Block) -> Vec<SourceSpan> {
    method block_entry (line 397) | pub fn block_entry(&self) -> Block {
    method block_args (line 400) | pub fn block_args<B>(&self, block: B) -> &[Value]
    method block_reads (line 408) | pub fn block_reads(&self, block: Block) -> &[Value] {
    method block_value (line 412) | pub fn block_value(&self, block: Block) -> Value {
    method block_walk_nested_values (line 416) | pub fn block_walk_nested_values<F, R>(&self, block: Block, visit: &mut...
    method block_walk_nested_values_mut (line 427) | pub fn block_walk_nested_values_mut<F, R>(
    method block_op_eq (line 443) | pub fn block_op_eq(&self, lb: Block, r_fun: &Function, rb: Block) -> b...
    method block_iter (line 459) | pub fn block_iter(&self) -> impl Iterator<Item = Block> {
    method graph_validate_block (line 468) | pub(crate) fn graph_validate_block(&self, block: Block) {
    method graph_validate_global (line 494) | pub fn graph_validate_global(&self) {
    method new (line 542) | pub fn new(span: SourceSpan, ident: FunctionIdent) -> Self {
    method ident (line 568) | pub fn ident(&self) -> &FunctionIdent {
    method entry_arg_num (line 572) | pub fn entry_arg_num(&self) -> usize {
  type GeneralSet (line 501) | pub trait GeneralSet<V> {
    method contains (line 502) | fn contains(&self, key: &V, fun: &Function) -> bool;
    method insert (line 503) | fn insert(&mut self, key: V, fun: &mut Function) -> bool;
  function contains (line 509) | fn contains(&self, key: &V, _fun: &Function) -> bool {
  function insert (line 512) | fn insert(&mut self, key: V, _fun: &mut Function) -> bool {
  function contains (line 520) | fn contains(&self, key: &V, fun: &Function) -> bool {
  function insert (line 523) | fn insert(&mut self, key: V, fun: &mut Function) -> bool {
  type SetPoolProvider (line 528) | pub trait SetPoolProvider: Sized + Copy {
    method pool (line 529) | fn pool(fun: &Function) -> &SetForest<Self>;
    method pool_mut (line 530) | fn pool_mut(fun: &mut Function) -> &mut SetForest<Self>;
    method pool (line 533) | fn pool(fun: &Function) -> &SetForest<Block> {
    method pool_mut (line 536) | fn pool_mut(fun: &mut Function) -> &mut SetForest<Block> {

FILE: libeir_ir/src/function/op.rs
  type CallKind (line 7) | pub enum CallKind {
  type BasicType (line 18) | pub enum BasicType {
  type MatchKind (line 39) | pub enum MatchKind {
  type MapPutUpdate (line 64) | pub enum MapPutUpdate {
  type OpKind (line 72) | pub enum OpKind {
    method is_call (line 141) | pub fn is_call(&self) -> bool {
    method get_dyn (line 148) | pub fn get_dyn<O: Op>(&self) -> Option<&O> {

FILE: libeir_ir/src/function/pool_container.rs
  type PoolContainer (line 7) | pub struct PoolContainer {

FILE: libeir_ir/src/function/primop.rs
  type BinOp (line 4) | pub enum BinOp {
    method symmetric (line 23) | pub fn symmetric(self) -> bool {
  type LogicOp (line 35) | pub enum LogicOp {
  type PrimOpKind (line 43) | pub enum PrimOpKind {

FILE: libeir_ir/src/function/serialize.rs
  method serialize (line 6) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: libeir_ir/src/function/value.rs
  type Value (line 11) | pub struct Value(u32);
    method aux_fmt (line 19) | fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, _aux: &C) -> std::f...
  method default (line 14) | fn default() -> Self {
  method make_id (line 26) | fn make_id(&self, out: &mut String) {
  type ValueData (line 33) | pub struct ValueData {
  type ValueKind (line 40) | pub enum ValueKind {
    method is_arg (line 48) | pub fn is_arg(&self) -> bool {
  type ValueMap (line 57) | pub struct ValueMap {
    method new (line 63) | pub fn new() -> Self {
    method push (line 70) | pub fn push(&mut self, kind: ValueKind) -> Value {
    method push_with_location (line 74) | pub fn push_with_location(&mut self, kind: ValueKind, location: Option...
    method get (line 88) | pub fn get(&self, kind: ValueKind) -> Option<Value> {
    type Output (line 94) | type Output = ValueData;
    method index (line 95) | fn index(&self, key: Value) -> &ValueData {
    method index_mut (line 100) | fn index_mut(&mut self, key: Value) -> &mut ValueData {

FILE: libeir_ir/src/graph/block_graph.rs
  method block_graph (line 17) | pub fn block_graph(&self) -> BlockGraph<'_> {
  type BlockGraph (line 32) | pub struct BlockGraph<'a> {
  function new (line 37) | pub fn new(fun: &'a Function) -> Self {
  function dfs (line 41) | pub fn dfs(&self) -> Dfs<Block, EntityVisitMap<Block>> {
  function dfs_iter (line 45) | pub fn dfs_iter(&'a self) -> impl Iterator<Item = Block> + 'a {
  function dfs_post_order (line 49) | pub fn dfs_post_order(&self) -> DfsPostOrder<Block, EntityVisitMap<Block...
  function dfs_post_order_iter (line 53) | pub fn dfs_post_order_iter(&'a self) -> impl Iterator<Item = Block> + 'a {
  function outgoing (line 57) | pub fn outgoing(&'a self, block: Block) -> impl Iterator<Item = Block> +...
  type BlockEdge (line 65) | pub struct BlockEdge(Block, usize);
  type BlockSuccessors (line 67) | pub struct BlockSuccessors<'a> {
  type Item (line 71) | type Item = Block;
  method next (line 73) | fn next(&mut self) -> Option<Block> {
  type BlockPredecessors (line 78) | pub struct BlockPredecessors<'a> {
  function new (line 82) | fn new(graph: &'a BlockGraph, block: Block) -> Self {
  type Item (line 91) | type Item = Block;
  method next (line 93) | fn next(&mut self) -> Option<Block> {
  type NodeId (line 99) | type NodeId = Block;
  type EdgeId (line 100) | type EdgeId = BlockEdge;
  type Neighbors (line 104) | type Neighbors = BlockSuccessors<'a>;
  method neighbors (line 106) | fn neighbors(self, block: Block) -> Self::Neighbors {
  type NeighborsDirected (line 115) | type NeighborsDirected = Either<BlockSuccessors<'a>, BlockPredecessors<'...
  method neighbors_directed (line 117) | fn neighbors_directed(self, block: Block, dir: Direction) -> Self::Neigh...
  type EntityVisitMap (line 125) | pub struct EntityVisitMap<E>
  function new (line 135) | pub fn new(size: usize) -> Self {
  function reset (line 140) | pub fn reset(&mut self, size: usize) {
  function visit (line 150) | fn visit(&mut self, a: E) -> bool {
  function is_visited (line 154) | fn is_visited(&self, a: &E) -> bool {
  type Map (line 160) | type Map = EntityVisitMap<Block>;
  method visit_map (line 162) | fn visit_map(&self) -> EntityVisitMap<Block> {
  method reset_map (line 166) | fn reset_map(&self, map: &mut EntityVisitMap<Block>) {
  function test_edge (line 182) | fn test_edge() {

FILE: libeir_ir/src/graph/control_flow_graph.rs
  method control_flow_graph (line 16) | pub fn control_flow_graph(&self) -> ControlFlowGraph {
  type CfgBranch (line 22) | pub struct CfgBranch(pub usize);
  type ControlFlowGraph (line 30) | pub struct ControlFlowGraph {
    method new (line 38) | pub fn new() -> Self {
    method calculate (line 47) | pub fn calculate(&mut self, fun: &Function, entry: Value) {
    method dfs (line 76) | pub fn dfs(&self) -> Dfs<Value, EntityVisitMap<Value>> {
    method dfs_iter (line 80) | pub fn dfs_iter<'a>(&'a self) -> impl Iterator<Item = Value> + 'a {
    method dfs_post_order (line 84) | pub fn dfs_post_order(&self) -> DfsPostOrder<Value, EntityVisitMap<Val...
    method dfs_post_order_iter (line 88) | pub fn dfs_post_order_iter<'a>(&'a self) -> impl Iterator<Item = Value...
  type NodeId (line 94) | type NodeId = Value;
  type EdgeId (line 95) | type EdgeId = CfgBranch;
  type ControlFlowSuccessors (line 98) | pub struct ControlFlowSuccessors<'a> {
  type Item (line 104) | type Item = Value;
  method next (line 105) | fn next(&mut self) -> Option<Value> {
  type ControlFlowPredecessors (line 115) | pub struct ControlFlowPredecessors<'a> {
  function new (line 121) | pub fn new(graph: &'a ControlFlowGraph, value: Value) -> Self {
  type Item (line 130) | type Item = Value;
  method next (line 131) | fn next(&mut self) -> Option<Value> {
  type Neighbors (line 142) | type Neighbors = ControlFlowSuccessors<'a>;
  method neighbors (line 143) | fn neighbors(self, value: Value) -> Self::Neighbors {
  type NeighborsDirected (line 152) | type NeighborsDirected = Either<ControlFlowSuccessors<'a>, ControlFlowPr...
  method neighbors_directed (line 153) | fn neighbors_directed(self, value: Value, dir: Direction) -> Self::Neigh...
  type Map (line 162) | type Map = EntityVisitMap<Value>;
  method visit_map (line 164) | fn visit_map(&self) -> EntityVisitMap<Value> {
  method reset_map (line 168) | fn reset_map(&self, map: &mut EntityVisitMap<Value>) {

FILE: libeir_ir/src/graph/live_block_graph.rs
  method live_block_graph (line 21) | pub fn live_block_graph(&self) -> LiveBlockGraph<'_> {
  type LiveBlockGraph (line 33) | pub struct LiveBlockGraph<'a> {
  function new (line 39) | pub fn new(fun: &'a Function) -> Self {
  function dfs (line 50) | pub fn dfs(&self) -> Dfs<Block, EntityVisitMap<Block>> {
  function dfs_iter (line 53) | pub fn dfs_iter(&'a self) -> impl Iterator<Item = Block> + 'a {
  function dfs_post_order (line 57) | pub fn dfs_post_order(&self) -> DfsPostOrder<Block, EntityVisitMap<Block...
  function dfs_post_order_iter (line 60) | pub fn dfs_post_order_iter(&'a self) -> impl Iterator<Item = Block> + 'a {
  function outgoing (line 64) | pub fn outgoing(&'a self, block: Block) -> impl Iterator<Item = Block> +...
  function incoming (line 68) | pub fn incoming(&'a self, block: Block) -> impl Iterator<Item = Block> +...
  type LiveBlockPredecessors (line 76) | pub struct LiveBlockPredecessors<'a> {
  function new (line 81) | fn new(graph: &'a LiveBlockGraph, block: Block) -> Self {
  type Item (line 91) | type Item = Block;
  method next (line 93) | fn next(&mut self) -> Option<Block> {
  type NodeId (line 104) | type NodeId = Block;
  type EdgeId (line 105) | type EdgeId = BlockEdge;
  type Neighbors (line 109) | type Neighbors = BlockSuccessors<'a>;
  method neighbors (line 111) | fn neighbors(self, block: Block) -> Self::Neighbors {
  type NeighborsDirected (line 117) | type NeighborsDirected = Either<BlockSuccessors<'a>, LiveBlockPredecesso...
  method neighbors_directed (line 119) | fn neighbors_directed(self, block: Block, dir: Direction) -> Self::Neigh...
  type Map (line 128) | type Map = EntityVisitMap<Block>;
  method visit_map (line 130) | fn visit_map(&self) -> EntityVisitMap<Block> {
  method reset_map (line 134) | fn reset_map(&self, map: &mut EntityVisitMap<Block>) {
  type NodeIterator (line 139) | pub struct NodeIterator(Vec<Block>, usize);
  type Item (line 141) | type Item = Block;
  method next (line 142) | fn next(&mut self) -> Option<Block> {
  type NodeIdentifiers (line 150) | type NodeIdentifiers = NodeIterator;
  method node_identifiers (line 151) | fn node_identifiers(self) -> Self::NodeIdentifiers {
  function test_back_edge (line 168) | fn test_back_edge() {

FILE: libeir_ir/src/ir_construct_macro.rs
  function basic_ir_build (line 110) | fn basic_ir_build() {

FILE: libeir_ir/src/lib.rs
  type FunctionIdent (line 65) | pub struct FunctionIdent {
  method cmp (line 71) | fn cmp(&self, other: &FunctionIdent) -> Ordering {
  method fmt (line 76) | fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {

FILE: libeir_ir/src/module.rs
  type FunctionDefinition (line 10) | pub struct FunctionDefinition {
    method index (line 15) | pub fn index(&self) -> FunctionIndex {
    method function (line 19) | pub fn function(&self) -> &Function {
    method function_mut (line 23) | pub fn function_mut(&mut self) -> &mut Function {
  type FunctionIndex (line 29) | pub struct FunctionIndex(u32);
  type Module (line 32) | pub struct Module {
    method new (line 39) | pub fn new(name: Ident) -> Self {
    method new_with_span (line 48) | pub fn new_with_span(name: Ident, span: SourceSpan) -> Self {
    method name (line 57) | pub fn name(&self) -> Ident {
    method span (line 61) | pub fn span(&self) -> SourceSpan {
    method add_function (line 65) | pub fn add_function(
    method ident_index (line 92) | pub fn ident_index(&self, ident: &FunctionIdent) -> Option<FunctionInd...
    method name_arity_index (line 95) | pub fn name_arity_index(&self, name: Symbol, arity: usize) -> Option<F...
    method function_iter (line 99) | pub fn function_iter(&self) -> impl Iterator<Item = &FunctionDefinitio...
    method function_iter_mut (line 102) | pub fn function_iter_mut(&mut self) -> impl Iterator<Item = &mut Funct...
    method index_iter (line 106) | pub fn index_iter(&self) -> impl Iterator<Item = FunctionIndex> {
    type Output (line 134) | type Output = FunctionDefinition;
    method index (line 135) | fn index(&self, idx: FunctionIndex) -> &FunctionDefinition {
    method index_mut (line 140) | fn index_mut(&mut self, idx: FunctionIndex) -> &mut FunctionDefinition {
    type Output (line 146) | type Output = FunctionDefinition;
    method index (line 147) | fn index(&self, ident: &FunctionIdent) -> &FunctionDefinition {
  method clone (line 111) | fn clone(&self) -> Self {

FILE: libeir_ir/src/operation/binary_construct.rs
  type BinaryConstructToken (line 52) | pub struct BinaryConstructToken(());
  type BinaryConstructStart (line 57) | pub struct BinaryConstructStart;
    method build (line 74) | pub fn build(builder: &mut FunctionBuilder, block: Block) -> Block {
    method build_target (line 81) | pub fn build_target(builder: &mut FunctionBuilder, block: Block, targe...
  method branches_len (line 62) | fn branches_len(&self) -> usize {
  method branch_num (line 65) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> V...
  type Token (line 92) | type Token = BinaryConstructToken;
  type BinaryConstructPush (line 99) | pub struct BinaryConstructPush {
    method build (line 140) | pub fn build(
    method build_target (line 155) | pub fn build_target(
  method name (line 105) | fn name(&self) -> &str {
  method dyn_clone (line 108) | fn dyn_clone(&self) -> DynOp {
  method type_id (line 111) | fn type_id(&self) -> TypeId {
  method meta_entry (line 114) | fn meta_entry(&self) -> &dyn MetaEntry {
  method op_eq (line 117) | fn op_eq(&self, other: &dyn Op) -> bool {
  method branches_len (line 127) | fn branches_len(&self) -> usize {
  method branch_num (line 130) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> V...
  type Token (line 186) | type Token = BinaryConstructToken;
  type BinaryConstructFinish (line 192) | pub struct BinaryConstructFinish;
    method build (line 223) | pub fn build(builder: &mut FunctionBuilder, block: Block, bin_ref: Val...
    method build_target (line 230) | pub fn build_target(
  method name (line 196) | fn name(&self) -> &str {
  method dyn_clone (line 199) | fn dyn_clone(&self) -> DynOp {
  method type_id (line 202) | fn type_id(&self) -> TypeId {
  method meta_entry (line 205) | fn meta_entry(&self) -> &dyn MetaEntry {
  method branches_len (line 211) | fn branches_len(&self) -> usize {
  method branch_num (line 214) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> V...
  type Token (line 246) | type Token = BinaryConstructToken;
  function register (line 249) | pub fn register(dialect: &mut Dialect) {

FILE: libeir_ir/src/operation/case.rs
  type CaseToken (line 16) | pub struct CaseToken(());
  type Case (line 37) | pub struct Case {
    method pat (line 43) | pub fn pat<'a>(&'a self) -> &'a PatternContainer {
    method clauses (line 46) | pub fn clauses<'a>(&'a self) -> &'a [PatternClause] {
    method builder (line 115) | pub fn builder() -> CaseBuilder {
  type Inner (line 52) | struct Inner {
  method name (line 58) | fn name(&self) -> &str {
  method dyn_clone (line 61) | fn dyn_clone(&self) -> DynOp {
  method type_id (line 64) | fn type_id(&self) -> TypeId {
  method meta_entry (line 67) | fn meta_entry(&self) -> &dyn MetaEntry {
  method op_eq (line 70) | fn op_eq(&self, other: &dyn Op) -> bool {
  method branches_len (line 80) | fn branches_len(&self) -> usize {
  method branch_num (line 83) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> V...
  method to_doc (line 97) | fn to_doc<'doc>(&self, ctx: &mut dyn FormatOpCtx<'doc>, _block: Block) -...
  type CaseBuilder (line 120) | pub struct CaseBuilder {
    method new (line 151) | pub fn new(span: SourceSpan) -> Self {
    method set_span (line 157) | pub fn set_span(&mut self, span: SourceSpan) {
    method push_clause (line 161) | pub fn push_clause<'a>(
    method push_value (line 172) | pub fn push_value<'a>(&mut self, value: Value, _b: &mut FunctionBuilde...
    method finish (line 176) | pub fn finish<'a>(self, block: Block, b: &mut FunctionBuilder<'a>) {
  method default (line 134) | fn default() -> Self {
  type Token (line 248) | type Token = CaseToken;
  type CaseParser (line 263) | struct CaseParser;
  method parse (line 265) | fn parse(
  function parse_case_body (line 283) | fn parse_case_body(ctx: &mut ParseCtx) -> Result<(), DynParserError> {
  function register (line 289) | pub fn register(dialect: &mut Dialect) {
  function basic_parse (line 301) | fn basic_parse() {

FILE: libeir_ir/src/operation/mod.rs
  type Op (line 33) | pub trait Op: MetaEntry + Send {
    method name (line 34) | fn name(&self) -> &str;
    method dyn_clone (line 36) | fn dyn_clone(&self) -> DynOp;
    method type_id (line 38) | fn type_id(&self) -> TypeId;
    method meta_entry (line 40) | fn meta_entry(&self) -> &dyn MetaEntry;
    method op_eq (line 45) | fn op_eq(&self, other: &dyn Op) -> bool {
    method debug_fmt (line 49) | fn debug_fmt(&self, formatter: &mut Formatter) -> FmtResult {
  function try_cast (line 55) | pub fn try_cast<T: Op>(&self) -> Option<&T> {
  function downcast_ref (line 62) | pub fn downcast_ref<T: Op>(&self) -> Option<&T> {
  function downcast_ref_unchecked (line 75) | pub unsafe fn downcast_ref_unchecked<T: Op>(&self) -> &T {
  type OpBuild (line 81) | pub trait OpBuild: Op {
  type DynOp (line 92) | pub struct DynOp(Value<dyn Op>);
    method new (line 95) | pub fn new<T: Op>(value: T) -> Self {
  type Target (line 101) | type Target = dyn Op;
  method deref (line 102) | fn deref(&self) -> &dyn Op {
  method clone (line 108) | fn clone(&self) -> Self {
  method fmt (line 114) | fn fmt(&self, formatter: &mut Formatter) -> FmtResult {

FILE: libeir_ir/src/operation/receive.rs
  type ReceiveToken (line 38) | pub struct ReceiveToken(());
  type ReceiveStart (line 53) | pub struct ReceiveStart;
    method build (line 99) | pub fn build(builder: &mut FunctionBuilder, block: Block, timeout: Val...
    method build_target (line 106) | pub fn build_target(
  method name (line 57) | fn name(&self) -> &str {
  method dyn_clone (line 60) | fn dyn_clone(&self) -> DynOp {
  method type_id (line 63) | fn type_id(&self) -> TypeId {
  method meta_entry (line 66) | fn meta_entry(&self) -> &dyn MetaEntry {
  method op_eq (line 69) | fn op_eq(&self, other: &dyn Op) -> bool {
  method branches_len (line 75) | fn branches_len(&self) -> usize {
  method branch_num (line 78) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> V...
  method to_doc (line 87) | fn to_doc<'doc>(&self, ctx: &mut dyn FormatOpCtx<'doc>, block: Block) ->...
  type Token (line 122) | type Token = ReceiveToken;
  type ReceiveWait (line 141) | pub struct ReceiveWait;
    method build (line 176) | pub fn build(builder: &mut FunctionBuilder, block: Block, recv_ref: Va...
    method build_target (line 187) | pub fn build_target(
  method name (line 145) | fn name(&self) -> &str {
  method dyn_clone (line 148) | fn dyn_clone(&self) -> DynOp {
  method type_id (line 151) | fn type_id(&self) -> TypeId {
  method meta_entry (line 154) | fn meta_entry(&self) -> &dyn MetaEntry {
  method op_eq (line 157) | fn op_eq(&self, other: &dyn Op) -> bool {
  method branches_len (line 163) | fn branches_len(&self) -> usize {
  method branch_num (line 166) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> V...
  type Token (line 205) | type Token = ReceiveToken;
  type ReceiveDone (line 225) | pub struct ReceiveDone;
    method build (line 259) | pub fn build(
    method build_target (line 275) | pub fn build_target(
  method name (line 229) | fn name(&self) -> &str {
  method dyn_clone (line 232) | fn dyn_clone(&self) -> DynOp {
  method type_id (line 235) | fn type_id(&self) -> TypeId {
  method meta_entry (line 238) | fn meta_entry(&self) -> &dyn MetaEntry {
  method op_eq (line 241) | fn op_eq(&self, other: &dyn Op) -> bool {
  method branches_len (line 247) | fn branches_len(&self) -> usize {
  method branch_num (line 250) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) -> V...
  type Token (line 293) | type Token = ReceiveToken;
  function register (line 296) | pub fn register(dialect: &mut Dialect) {

FILE: libeir_ir/src/pattern/fmt.rs
  method fmt (line 5) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: libeir_ir/src/pattern/mod.rs
  type PatternNode (line 12) | pub struct PatternNode(u32);
  type PatternValue (line 18) | pub struct PatternValue(u32);
  type PatternClause (line 22) | pub struct PatternClause(u32);
  type PatternContainer (line 26) | pub struct PatternContainer {
    method new (line 127) | pub fn new() -> Self {
    method clause_value (line 131) | pub fn clause_value(&mut self, clause: PatternClause) -> PatternValue {
    method clause_node_value (line 137) | pub fn clause_node_value(&mut self, clause: PatternClause, node: Patte...
    method node_empty (line 147) | pub fn node_empty(&mut self, span: Option<SourceSpan>) -> PatternNode {
    method binary (line 155) | pub fn binary(
    method wildcard (line 175) | pub fn wildcard(&mut self, node: PatternNode) {
    method constant (line 182) | pub fn constant(&mut self, node: PatternNode, val: Const) {
    method value (line 189) | pub fn value(&mut self, node: PatternNode, val: PatternValue) {
    method tuple (line 196) | pub fn tuple(&mut self, node: PatternNode) {
    method tuple_elem_push (line 202) | pub fn tuple_elem_push(&mut self, tup: PatternNode, node: PatternNode) {
    method list (line 213) | pub fn list(&mut self, node: PatternNode, head: PatternNode, tail: Pat...
    method map (line 220) | pub fn map(&mut self, node: PatternNode) {
    method map_push (line 229) | pub fn map_push(&mut self, map: PatternNode, key: PatternValue, value:...
    method node_finish (line 245) | pub fn node_finish(&mut self, node: PatternNode) {
    method node_set_span (line 251) | pub fn node_set_span(&mut self, node: PatternNode, span: SourceSpan) {
    method clause_start (line 255) | pub fn clause_start(&mut self, span: SourceSpan) -> PatternClause {
    method clause_node_push (line 270) | pub fn clause_node_push(&mut self, clause: PatternClause, node: Patter...
    method clause_bind_push (line 276) | pub fn clause_bind_push(&mut self, clause: PatternClause, node: Patter...
    method clause_value_push (line 282) | pub fn clause_value_push(&mut self, clause: PatternClause, val: Patter...
    method clause_finish (line 288) | pub fn clause_finish(&mut self, clause: PatternClause) {
    method copy_from (line 295) | pub fn copy_from(&mut self, clause: PatternClause, from: &PatternConta...
    method update_binds (line 341) | pub fn update_binds(&mut self, clause: PatternClause, map: &HashMap<Pa...
    method clause_root_nodes (line 355) | pub fn clause_root_nodes(&self, clause: PatternClause) -> &[PatternNod...
    method clause_binds (line 360) | pub fn clause_binds(&self, clause: PatternClause) -> &[PatternNode] {
    method clause_values (line 365) | pub fn clause_values(&self, clause: PatternClause) -> &[PatternValue] {
    method clause_node_binds_iter (line 370) | pub fn clause_node_binds_iter<'a>(
    method node_span (line 387) | pub fn node_span(&self, node: PatternNode) -> SourceSpan {
    method node_kind (line 391) | pub fn node_kind(&self, node: PatternNode) -> &PatternNodeKind {
    method merge_patterns (line 462) | pub fn merge_patterns(
    method merge_pattern_constant (line 575) | pub fn merge_pattern_constant(
    method make_structural (line 685) | pub fn make_structural(&mut self, clause: PatternClause) -> PatternCla...
  method default (line 40) | fn default() -> PatternContainer {
  type PatternClauseData (line 56) | struct PatternClauseData {
  type PatternNodeData (line 78) | struct PatternNodeData {
  type PatternNodeKind (line 85) | pub enum PatternNodeKind {
  type PatternBinaryEntryData (line 108) | pub struct PatternBinaryEntryData {}
  type PatternMergeFail (line 110) | pub enum PatternMergeFail {
  function copy_pattern_node (line 396) | fn copy_pattern_node(

FILE: libeir_ir/src/text/ast/mod.rs
  type DynToken (line 8) | pub enum DynToken {
    method span (line 51) | pub fn span(&self) -> SourceSpan {
  type Module (line 98) | pub struct Module {
  type ModuleItem (line 105) | pub enum ModuleItem {
  type Function (line 110) | pub struct Function {
  type FunctionItem (line 118) | pub enum FunctionItem {
  type Meta (line 126) | pub struct Meta {
  type Label (line 133) | pub struct Label {
  type Assignment (line 141) | pub struct Assignment {
  type Op (line 148) | pub enum Op {
  type CaseOp (line 161) | pub struct CaseOp {
  type CaseEntry (line 169) | pub struct CaseEntry {
  type CasePattern (line 178) | pub enum CasePattern {
  type MatchOp (line 195) | pub struct MatchOp {
  type MatchEntry (line 201) | pub struct MatchEntry {
  type MatchKind (line 207) | pub enum MatchKind {
  type UnpackValueListOp (line 218) | pub struct UnpackValueListOp {
  type CallControlFlowOp (line 226) | pub struct CallControlFlowOp {
  type CallFunctionOp (line 232) | pub struct CallFunctionOp {
  type IfBoolOp (line 241) | pub struct IfBoolOp {
  type TraceCaptureRawOp (line 250) | pub struct TraceCaptureRawOp {
  type Value (line 256) | pub enum Value {
    method value (line 272) | pub fn value(&self) -> Option<Ident> {
    method block (line 278) | pub fn block(&self) -> Option<Ident> {

FILE: libeir_ir/src/text/ast/raise.rs
  type RaiseCtx (line 11) | struct RaiseCtx {
    method block_name (line 16) | pub fn block_name(&mut self, _block: Block) -> Ident {
    method value_name (line 20) | pub fn value_name(&mut self, _value: Value) -> Ident {
  method raise (line 26) | pub fn raise(&self) -> ast::Function {

FILE: libeir_ir/src/text/dot_printer.rs
  function function_into_graph_printer (line 12) | pub fn function_into_graph_printer<O>(fun: &Function, g: &mut GraphPrint...
  function function_to_dot (line 56) | pub fn function_to_dot(fun: &Function) -> String {

FILE: libeir_ir/src/text/lower/location.rs
  type ParsedTerminalLocation (line 6) | pub struct ParsedTerminalLocation {
  type ParsedLocation (line 13) | pub struct ParsedLocation {
  function parse_terminal_location (line 17) | pub fn parse_terminal_location(
  function parse_location (line 47) | pub fn parse_location(ctx: &mut ParseCtx) -> Result<ParsedLocation, DynP...

FILE: libeir_ir/src/text/lower/mod.rs
  type ErrCollector (line 17) | type ErrCollector<'a> = &'a mut dyn ErrorReceiver<E = LowerError, W = Lo...
  type LowerContext (line 19) | pub struct LowerContext<'a, 'b> {
  function error (line 26) | pub fn error<T: ToDiagnostic>(&mut self, diag: T) {
  type LowerError (line 34) | pub enum LowerError {
  method to_diagnostic (line 72) | fn to_diagnostic(&self) -> Diagnostic {
  type LowerMap (line 109) | pub struct LowerMap {
    method get_value (line 114) | pub fn get_value(&self, ident: &str) -> Value {
    method get_block (line 118) | pub fn get_block(&self, ident: &str) -> Block {
  function lower (line 124) | pub fn lower(&self, errors: ErrCollector) -> Result<Module, ()> {
  type Name (line 146) | pub enum Name {
    method span (line 151) | pub fn span(&self) -> SourceSpan {
  function insert_check_duplicate (line 159) | fn insert_check_duplicate(
  function lower (line 178) | pub fn lower(&self, errors: ErrCollector, module: Ident) -> Result<(Func...
  function lower_into (line 192) | pub fn lower_into(
  function lower_operation (line 328) | fn lower_operation(
  function lower_case_pattern (line 480) | fn lower_case_pattern(
  function lower_value (line 510) | fn lower_value(

FILE: libeir_ir/src/text/parse_dyn/mod.rs
  type Nesting (line 10) | pub enum Nesting {
  type Token (line 20) | pub enum Token {
  function flatten_dyn_token (line 68) | pub fn flatten_dyn_token(tok: &[DynToken]) -> Vec<(Token, SourceSpan)> {
  type ParseCtx (line 225) | pub struct ParseCtx<'a> {
  type DynParserError (line 233) | pub enum DynParserError {
  method to_diagnostic (line 239) | fn to_diagnostic(&self) -> Diagnostic {
  function new (line 252) | pub fn new(tokens: &'a [DynToken], span: SourceSpan) -> Self {
  function pop (line 260) | pub fn pop(&mut self) -> Result<&'a DynToken, DynParserError> {
  function peek (line 277) | pub fn peek(&self) -> Option<&'a DynToken> {
  function try_parse (line 281) | pub fn try_parse<R, E>(
  function comma (line 295) | pub fn comma<R, E>(
  function repeat_any (line 314) | pub fn repeat_any<R, E>(&mut self, fun: impl Fn(&mut ParseCtx) -> Result...
  function eof (line 325) | pub fn eof(&mut self) -> Result<(), DynParserError> {
  function tok_string (line 332) | pub fn tok_string(&mut self) -> Result<Ident, DynParserError> {
  function tok_integer (line 338) | pub fn tok_integer(&mut self) -> Result<(&'a Integer, SourceSpan), DynPa...
  function tok_colon (line 345) | pub fn tok_colon(&mut self) -> Result<SourceSpan, DynParserError> {
  function tok_at (line 351) | pub fn tok_at(&mut self) -> Result<SourceSpan, DynParserError> {
  type ParsePos (line 365) | pub struct ParsePos(usize);
  function val (line 367) | pub fn val(ctx: &mut ParseCtx) -> Result<Value, DynParserError> {
  function val_value_list (line 383) | pub fn val_value_list(ctx: &mut ParseCtx) -> Result<Value, DynParserErro...
  function val_list (line 400) | pub fn val_list(ctx: &mut ParseCtx) -> Result<Value, DynParserError> {
  function val_atomic (line 419) | pub fn val_atomic(ctx: &mut ParseCtx) -> Result<Value, DynParserError> {

FILE: libeir_ir/src/text/parser/errors.rs
  type ParseError (line 10) | pub type ParseError = lalrpop_util::ParseError<SourceIndex, Token, Parse...
  type Errors (line 12) | pub type Errors = libeir_util_parse::Errors<ParserError, ParserError>;
  type ParserError (line 16) | pub enum ParserError {
    method span (line 61) | pub fn span(&self) -> Option<SourceSpan> {
    method from (line 99) | fn from(err: LowerError) -> ParserError {
    method from (line 104) | fn from(err: ParseError) -> ParserError {
    method from (line 131) | fn from(diagnostic: Diagnostic) -> ParserError {
  method to_diagnostic (line 72) | fn to_diagnostic(&self) -> Diagnostic {

FILE: libeir_ir/src/text/parser/lexer.rs
  type LexicalError (line 58) | pub struct LexicalError;
  type LexicalToken (line 61) | pub struct LexicalToken(pub SourceIndex, pub Token, pub SourceIndex);
    method token (line 63) | pub fn token(&self) -> Token {
    method span (line 67) | pub fn span(&self) -> SourceSpan {
  type Token (line 73) | pub enum Token {
  function is_escapechar (line 151) | fn is_escapechar(c: char) -> bool {
  function is_control (line 165) | fn is_control(c: char) -> bool {
  function is_inputchar (line 168) | fn is_inputchar(c: char) -> bool {
  function is_digit (line 171) | fn is_digit(c: char) -> bool {
  function is_octal (line 174) | fn is_octal(c: char) -> bool {
  function is_uppercase (line 177) | fn is_uppercase(c: char) -> bool {
  function is_lowercase (line 182) | fn is_lowercase(c: char) -> bool {
  function is_namechar (line 187) | fn is_namechar(c: char) -> bool {
  type Lexer (line 191) | pub struct Lexer<S> {
  function new (line 203) | pub fn new(scanner: Scanner<S>) -> Self {
  function lex (line 216) | pub fn lex(&mut self) -> Option<<Self as Iterator>::Item> {
  function advance (line 237) | fn advance(&mut self) {
  function advance_start (line 242) | fn advance_start(&mut self) {
  function pop (line 282) | fn pop(&mut self) -> char {
  function peek (line 287) | fn peek(&mut self) -> char {
  function peek_next (line 290) | fn peek_next(&mut self) -> char {
  function read (line 293) | fn read(&mut self) -> char {
  function skip (line 296) | fn skip(&mut self) {
  function span (line 299) | pub fn span(&self) -> SourceSpan {
  function slice (line 302) | fn slice(&self) -> &str {
  function slice_span (line 305) | fn slice_span(&self, span: impl Into<Range<usize>>) -> &str {
  function ident (line 308) | fn ident(&self) -> Ident {
  function skip_whitespace (line 312) | fn skip_whitespace(&mut self) {
  function tokenize (line 319) | fn tokenize(&mut self) -> Token {
  function lex_ident (line 369) | fn lex_ident(&mut self) -> Token {
  function lex_string (line 391) | fn lex_string(&mut self) -> Token {
  function lex_variable (line 415) | fn lex_variable(&mut self) -> Token {
  function lex_integer (line 434) | fn lex_integer(&mut self) -> Token {
  function lex_atom (line 449) | fn lex_atom(&mut self) -> Token {
  type Item (line 482) | type Item = Result<(SourceIndex, Token, SourceIndex), ParserError>;
  method next (line 484) | fn next(&mut self) -> Option<Self::Item> {

FILE: libeir_ir/src/text/parser/mod.rs
  type Parser (line 20) | pub type Parser = parse::Parser<()>;
  type ParserErrorReceiver (line 22) | type ParserErrorReceiver<'a> = dyn ErrorReceiver<E = ParserError, W = Pa...
  type NamedFunction (line 51) | pub struct NamedFunction {
  type Parser (line 57) | type Parser = self::grammar::ModuleParser;
  type Error (line 58) | type Error = ParserError;
  type Config (line 59) | type Config = ();
  type Token (line 60) | type Token = std::result::Result<(SourceIndex, Token, SourceIndex), Pars...
  method root_file_error (line 62) | fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> ...
  method parse_tokens (line 66) | fn parse_tokens<S>(errors: &mut ParserErrorReceiver, tokens: S) -> Resul...
  method parse (line 88) | fn parse<S>(_parser: &Parser, errors: &mut ParserErrorReceiver, source: ...
  type Parser (line 98) | type Parser = self::grammar::StandaloneFunctionParser;
  type Error (line 99) | type Error = ParserError;
  type Config (line 100) | type Config = ();
  type Token (line 101) | type Token = std::result::Result<(SourceIndex, Token, SourceIndex), Pars...
  method root_file_error (line 103) | fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> ...
  method parse_tokens (line 107) | fn parse_tokens<S>(errors: &mut ParserErrorReceiver, tokens: S) -> Resul...
  method parse (line 133) | fn parse<'a, S>(
  method parse (line 148) | pub fn parse(string: &str) -> std::result::Result<Self, ()> {
  method parse_with_module (line 168) | pub fn parse_with_module(string: &str, module: Ident) -> std::result::Re...
  function module_codemap (line 189) | pub fn module_codemap(text: &str, codemap: Arc<CodeMap>) -> (Result<crat...
  function module (line 213) | pub fn module(text: &str) -> (Result<crate::Module, ()>, Errors) {
  function module_unwrap (line 217) | pub fn module_unwrap(text: &str) -> crate::Module {
  function function_map_codemap (line 231) | pub fn function_map_codemap(
  function function_map (line 258) | pub fn function_map(text: &str) -> (Result<(crate::Function, LowerMap), ...
  function function_codemap (line 262) | pub fn function_codemap(
  function function (line 272) | pub fn function(text: &str) -> (Result<crate::Function, ()>, Errors) {
  function function_unwrap (line 279) | pub fn function_unwrap(text: &str) -> crate::Function {
  function function_map_unwrap (line 293) | pub fn function_map_unwrap(text: &str) -> (crate::Function, LowerMap) {
  function parse_empty_function (line 323) | fn parse_empty_function() {
  function lower_empty_function_fails (line 336) | fn lower_empty_function_fails() {
  function parse_kitchen_sink (line 341) | fn parse_kitchen_sink() {
  function lower_add_one (line 417) | fn lower_add_one() {
  function location (line 430) | fn location() {

FILE: libeir_ir/src/text/printer.old.rs
  type EirAnnotator (line 56) | pub trait EirAnnotator {
    method annotate_function (line 57) | fn annotate_function(&mut self, out: &mut String, fun: &Function);
    method annotate_block (line 58) | fn annotate_block(&mut self, out: &mut String, fun: &Function, block: ...
  type ToEirTextContext (line 93) | pub struct ToEirTextContext {
    method new (line 99) | pub fn new() -> Self {
    method add_annotator (line 102) | pub fn add_annotator<T>(&mut self, ann: T) where T: EirAnnotator + 'st...
    method annotate_function (line 105) | pub fn annotate_function(&mut self, fun: &Function) {
    method annotate_block (line 110) | pub fn annotate_block(&mut self, fun: &Function, block: Block) -> Opti...
  type ToEirText (line 123) | pub trait ToEirText {
    method to_eir_text (line 124) | fn to_eir_text(&self, ctx: &mut ToEirTextContext, indent: usize, out: ...
    method to_eir_text (line 139) | fn to_eir_text(&self, _ctx: &mut ToEirTextContext, indent: usize, out:...
    method to_eir_text (line 172) | fn to_eir_text(&self, ctx: &mut ToEirTextContext, indent: usize, out: ...
    method to_eir_text (line 193) | fn to_eir_text(&self, ctx: &mut ToEirTextContext, indent: usize, out: ...
  type ToEirTextFun (line 126) | pub trait ToEirTextFun {
    method to_eir_text_fun (line 127) | fn to_eir_text_fun(&self, ctx: &mut ToEirTextContext, fun: &Function, ...
    method to_eir_text_fun (line 257) | fn to_eir_text_fun(&self, ctx: &mut ToEirTextContext, fun: &Function,
  function write_indent (line 131) | fn write_indent(out: &mut dyn Write, indent: usize) -> std::io::Result<(...
  function print_constants (line 147) | pub fn print_constants(_ctx: &mut ToEirTextContext, _fun: &Function, _in...
  function format_pattern (line 231) | fn format_pattern(_ctx: &mut ToEirTextContext, pat: &PatternContainer, _...
  function get_value_list (line 245) | fn get_value_list<'a>(fun: &'a Function, value: Value) -> Option<&'a [Va...
  function format_value (line 553) | fn format_value(value: Value, fun: &Function, out: &mut dyn Write) -> st...
  function format_value_list (line 564) | fn format_value_list(values: &[Value], fun: &Function,

FILE: libeir_ir/src/text/printer/constant.rs
  function constant_to_doc (line 5) | pub fn constant_to_doc<'a>(
  type ConstantState (line 14) | enum ConstantState {
  function constant_to_doc_state (line 31) | fn constant_to_doc_state<'a>(
  function atomic_to_doc (line 123) | fn atomic_to_doc<'a>(arena: &'a Arena<'a>, atomic: &AtomicTerm) -> RefDo...

FILE: libeir_ir/src/text/printer/mod.rs
  type DynError (line 20) | type DynError = Box<dyn Error>;
  function get_value_list (line 40) | fn get_value_list<'a>(fun: &'a Function, value: Value) -> Option<&'a [Va...
  type FormatConfig (line 50) | pub struct FormatConfig<B, V, L>
  type StandardFormatConfig (line 70) | pub type StandardFormatConfig =
  method default (line 73) | fn default() -> Self {
  type FormatState (line 84) | pub struct FormatState<'a> {
  type BlockIteratorConfig (line 90) | pub trait BlockIteratorConfig {
    method new (line 92) | fn new(&self, fun: &Function) -> Self::Iter;
    type Iter (line 103) | type Iter = DfsBlockIterator;
    method new (line 104) | fn new(&self, fun: &Function) -> Self::Iter {
  type BlockIterator (line 97) | pub trait BlockIterator {
    method next (line 98) | fn next(&mut self, fun: &Function) -> Option<Block>;
    method next (line 115) | fn next(&mut self, fun: &Function) -> Option<Block> {
  type DfsBlockIteratorConfig (line 101) | pub struct DfsBlockIteratorConfig;
  type DfsBlockIterator (line 111) | pub struct DfsBlockIterator {
  type ValueSite (line 122) | pub enum ValueSite {
  type ValueFormatter (line 126) | pub trait ValueFormatter {
    method value (line 127) | fn value(&self, out: &mut String, fun: &Function, site: ValueSite, val...
    method value (line 134) | fn value(&self, out: &mut String, fun: &Function, _site: ValueSite, va...
  type StandardValueFormatter (line 132) | pub struct StandardValueFormatter;
  type BlockValueLayout (line 142) | pub trait BlockValueLayout {
    method layout_module (line 145) | fn layout_module(&mut self, fun: &Function);
    method layout (line 147) | fn layout(&mut self, fun: &Function, block: Block);
    method values (line 150) | fn values(&self) -> &[Value];
    method should_layout (line 154) | fn should_layout(&self, value: Value, within: Option<Value>) -> bool;
    method layout_module (line 170) | fn layout_module(&mut self, fun: &Function) {}
    method layout (line 171) | fn layout(&mut self, fun: &Function, block: Block) {
    method values (line 195) | fn values(&self) -> &[Value] {
    method should_layout (line 199) | fn should_layout(&self, value: Value, within: Option<Value>) -> bool {
  type ReferencePrimopBlockValueLayout (line 157) | pub struct ReferencePrimopBlockValueLayout {
  method default (line 162) | fn default() -> Self {
  type BlockFormatSink (line 204) | pub trait BlockFormatSink {
    method write_indent (line 207) | fn write_indent(&mut self, num: usize) -> Result<(), DynError> {
    method write_str (line 214) | fn write_str(&mut self, string: &str) -> Result<(), DynError>;
    method commit_line (line 215) | fn commit_line(&mut self) -> Result<Self::LineIndex, DynError>;
    method block_lines (line 221) | fn block_lines(&mut self, _block: Block, _range: (Self::LineIndex, Sel...
    type LineIndex (line 238) | type LineIndex = ();
    method write_str (line 239) | fn write_str(&mut self, string: &str) -> Result<(), DynError> {
    method commit_line (line 243) | fn commit_line(&mut self) -> Result<(), DynError> {
  type StringSink (line 224) | pub struct StringSink {
    method new (line 228) | pub fn new() -> Self {
    method finalize (line 233) | pub fn finalize(self) -> String {
  type FunctionFormatData (line 249) | pub(crate) struct FunctionFormatData<'a, B, V, L>
  function block_to_doc (line 266) | pub(crate) fn block_to_doc(
  function block_body_to_doc (line 316) | pub(crate) fn block_body_to_doc(
  function value_assign_to_doc (line 352) | pub(crate) fn value_assign_to_doc(
  function constant (line 448) | fn constant(
  function value_use_only (line 457) | fn value_use_only(
  function value_use (line 470) | fn value_use(
  function format_callee (line 487) | fn format_callee(
  function format_function_body_state (line 537) | fn format_function_body_state<B, V, L, S>(
  function format_function_body (line 585) | pub fn format_function_body<B, V, L, S>(
  function format_module (line 603) | pub fn format_module<B, V, L, S>(
  method to_text (line 639) | pub fn to_text<B, V, L>(&self, config: &mut FormatConfig<B, V, L>) -> St...
  method to_text_standard (line 650) | pub fn to_text_standard(&self) -> String {
  method block_to_text (line 654) | pub fn block_to_text<B, V, L>(&self, block: Block, config: &mut FormatCo...
  method to_text (line 684) | pub fn to_text<B, V, L>(&self, config: &mut FormatConfig<B, V, L>) -> St...
  method to_text_standard (line 695) | pub fn to_text_standard(&self) -> String {
  function woo (line 705) | fn woo() {

FILE: libeir_ir/src/text/printer/operation.rs
  type FormatOpCtxImpl (line 13) | pub struct FormatOpCtxImpl<'a, 'b, 'doc, B, V, L>
  function arena (line 30) | fn arena(&self) -> &'doc pretty::Arena<'doc> {
  function value_use_to_doc (line 34) | fn value_use_to_doc(&mut self, value: DynValue) -> RefDoc<'doc, ()> {
  function binary_specifier_to_doc (line 41) | fn binary_specifier_to_doc<'a>(
  function block_op_to_doc (line 112) | pub fn block_op_to_doc(
  function type_to_text (line 407) | fn type_to_text(ty: &BasicType) -> String {

FILE: libeir_ir/src/traits/op_branches.rs
  type OpBranches (line 6) | pub trait OpBranches {
    method branches_len (line 10) | fn branches_len(&self) -> usize;
    method branch_num (line 14) | fn branch_num(&self, fun: &Function, block: Block, branch_n: usize) ->...

FILE: libeir_ir/src/traits/parser.rs
  type OpParser (line 5) | pub trait OpParser: Send + Sync {
    method parse (line 6) | fn parse(

FILE: libeir_ir/src/traits/printer.rs
  type FormatOpCtx (line 5) | pub trait FormatOpCtx<'doc> {
    method arena (line 6) | fn arena(&self) -> &'doc pretty::Arena<'doc>;
    method value_use_to_doc (line 7) | fn value_use_to_doc(&mut self, value: DynValue) -> RefDoc<'doc, ()>;
  type OpPrinter (line 10) | pub trait OpPrinter {
    method to_doc (line 11) | fn to_doc<'doc>(&self, ctx: &mut dyn FormatOpCtx<'doc>, block: Block) ...

FILE: libeir_lowerutils/src/lib.rs
  type LowerData (line 13) | pub struct LowerData {
  type Escape (line 22) | enum Escape {
  function analyze (line 27) | pub fn analyze(fun: &Function) -> LowerData {

FILE: libeir_lowerutils/src/tests.rs
  function simple_function (line 4) | fn simple_function() {
  function nested_functions (line 23) | fn nested_functions() {

FILE: libeir_passes/src/compile_pattern/erlang_pattern_provider.rs
  type ValueOrConst (line 17) | pub enum ValueOrConst {
    method from_value (line 24) | fn from_value(val_bind: ValueBind, fun: &Function) -> Self {
  type NodeKind (line 38) | pub enum NodeKind {
    method num_children (line 68) | pub fn num_children(self) -> usize {
  type NodeData (line 84) | pub struct NodeData {
  type ErlangPatternProvider (line 90) | pub struct ErlangPatternProvider<'a> {
  type Node (line 109) | pub struct Node(u32);
  type Var (line 113) | pub struct Var(u32);
  function new (line 117) | pub fn new() -> Self {
  function add_child (line 144) | pub fn add_child(&mut self, node: Node, kind: NodeKind, pat_node: Patter...
  function add_clause (line 154) | pub fn add_clause(&mut self) -> Node {
  function wildcard (line 163) | fn wildcard(&self) -> Node {
  function pattern_node_to_cfg_node (line 167) | pub fn pattern_node_to_cfg_node(&self, pat: PatternNode) -> Node {
  type PatternNodeKey (line 173) | type PatternNodeKey = Node;
  type PatternNodeKind (line 174) | type PatternNodeKind = NodeKind;
  type CfgVariable (line 175) | type CfgVariable = Var;
  constant WILDCARD (line 177) | const WILDCARD: NodeKind = NodeKind::Wildcard;
  method get_root (line 179) | fn get_root(&self) -> ExpandedClauseNodes<Var, Node> {
  method kind_includes (line 187) | fn kind_includes(&self, kind: NodeKind, key: Node) -> bool {
  method get_kind (line 201) | fn get_kind(&self, key: Node) -> NodeKind {
  method get_wildcard_node (line 205) | fn get_wildcard_node(&self) -> Node {
  method expand_clause_nodes (line 209) | fn expand_clause_nodes(
  function pattern_node_to_provider (line 348) | fn pattern_node_to_provider(
  function pattern_to_provider (line 467) | pub(super) fn pattern_to_provider<'a>(

FILE: libeir_passes/src/compile_pattern/lower_cfg.rs
  type DecisionTreeDestinations (line 14) | pub struct DecisionTreeDestinations<'bump> {
  type LowerCtx (line 20) | struct LowerCtx<'a, 'b, 'bump> {
  function node_to_value (line 27) | fn node_to_value(
  function value_or_const_to_value (line 41) | fn value_or_const_to_value(
  function get_var_value (line 56) | fn get_var_value(&self, var: Var) -> Value {
  function bind (line 60) | fn bind(&mut self, var: Var, val: Value) {
  function lower_cfg (line 65) | pub fn lower_cfg(
  function lower_cfg_rec (line 150) | fn lower_cfg_rec(

FILE: libeir_passes/src/compile_pattern/mod.rs
  type BFnvHashMap (line 5) | type BFnvHashMap<'bump, K, V> = HashMap<K, V, FnvBuildHasher, &'bump Bump>;
  type CompilePatternPass (line 26) | pub struct CompilePatternPass {
    method new (line 31) | pub fn new() -> Self {
    method compile_pattern (line 48) | pub fn compile_pattern(&mut self, b: &mut FunctionBuilder) {
  method name (line 39) | fn name(&self) -> &str {
  method run_function_pass (line 42) | fn run_function_pass(&mut self, b: &mut FunctionBuilder) {
  type ValueBind (line 176) | pub(super) enum ValueBind {

FILE: libeir_passes/src/lib.rs
  type FunctionPass (line 22) | pub trait FunctionPass {
    method name (line 23) | fn name(&self) -> &str;
    method run_function_pass (line 24) | fn run_function_pass(&mut self, b: &mut FunctionBuilder);
  type PassType (line 27) | enum PassType {
  type PassManager (line 31) | pub struct PassManager {
    method new (line 36) | pub fn new() -> Self {
    method push_function_pass (line 40) | pub fn push_function_pass<P>(&mut self, pass: P)
    method run (line 47) | pub fn run(&mut self, module: &mut Module) {
  method default (line 70) | fn default() -> Self {

FILE: libeir_passes/src/naive_inline_closures/mod.rs
  type NaiveInlineClosuresPass (line 13) | pub struct NaiveInlineClosuresPass {
    method new (line 19) | pub fn new() -> Self {
    method inline_closures (line 37) | pub fn inline_closures(&mut self, b: &mut FunctionBuilder) {
  method name (line 28) | fn name(&self) -> &str {
  method run_function_pass (line 31) | fn run_function_pass(&mut self, b: &mut FunctionBuilder) {

FILE: libeir_passes/src/naive_inline_closures/tests.rs
  function inline_basic_function (line 6) | fn inline_basic_function() {
  function inline_nested_functions (line 52) | fn inline_nested_functions() {

FILE: libeir_passes/src/simplify_cfg/analyze/call.rs
  function propagate (line 5) | pub(super) fn propagate(ctx: &mut AnalysisContext, block: Block) -> bool {

FILE: libeir_passes/src/simplify_cfg/analyze/if_bool.rs
  function propagate (line 5) | pub(super) fn propagate(ctx: &mut AnalysisContext, block: Block) -> bool {

FILE: libeir_passes/src/simplify_cfg/analyze/mod.rs
  type BlockEdge (line 20) | type BlockEdge = (Block, Block);
  type GraphAnalysis (line 23) | pub struct GraphAnalysis<'bump> {
  type TreeData (line 36) | pub struct TreeData<'bump> {
  function is_before (line 44) | fn is_before(&self, lhs: Block, rhs: Block) -> bool {
  function is_value_relevant (line 60) | fn is_value_relevant(&self, tree_target: Block, value: Value) -> bool {
  type ChainAnalysis (line 77) | pub struct ChainAnalysis<'bump> {
  type CondValue (line 94) | pub struct CondValue<'bump> {
  type PhiSource (line 102) | pub struct PhiSource {
  type EntryEdgeAnalysis (line 119) | pub struct EntryEdgeAnalysis<'bump> {
  type AnalysisContext (line 134) | struct AnalysisContext<'bump, 'a> {
  function init_block (line 147) | fn init_block(&mut self, block: Block) {
  function follow (line 152) | pub fn follow(&self, mut val: Value) -> Value {
  function set_branch (line 160) | pub fn set_branch(&mut self, target: Value) {
  function add_rename (line 164) | pub fn add_rename(&mut self, callee: Block, caller_read: Value, callee_a...
  function analyze_graph (line 209) | pub fn analyze_graph<'bump, 'fun>(
  type ChainMapping (line 409) | pub struct ChainMapping {
    method iter_entries_for (line 414) | pub fn iter_entries_for<'a>(&'a self, block: Block) -> impl Iterator<I...
    method entry_to_chain (line 417) | pub fn entry_to_chain(&self, entry: Block) -> Chain {
  function build_node (line 422) | pub fn build_node<'bump>(
  function analyze_chain (line 566) | pub fn analyze_chain<'bump>(

FILE: libeir_passes/src/simplify_cfg/analyze/unpack_value_list.rs
  function propagate (line 5) | pub(super) fn propagate(ctx: &mut AnalysisContext, block: Block, n: usiz...

FILE: libeir_passes/src/simplify_cfg/chain_graph/mod.rs
  type ValueRef (line 22) | pub enum ValueRef {
  type Node (line 28) | pub struct Node(u32);
  method make_id (line 31) | fn make_id(&self, out: &mut String) {
  type Chain (line 38) | pub struct Chain(u32);
  method make_id (line 41) | fn make_id(&self, out: &mut String) {
  type ChainGraph (line 80) | pub struct ChainGraph {
    method new (line 115) | pub fn new(target_block: Block) -> Self {
    method propagate_alias (line 139) | pub fn propagate_alias(&self, mut node: Node) -> Node {
    method get_terminal_value_node (line 149) | pub fn get_terminal_value_node(&self, value: Value) -> Option<Node> {
    method get_member_value_node (line 153) | pub fn get_member_value_node(&self, value: Value) -> Option<Node> {
    method get_member_or_terminal (line 158) | pub fn get_member_or_terminal(&self, value: Value) -> Option<Node> {
    method mark_root (line 172) | pub fn mark_root(&mut self, value: Value, node: Node) {
    method get_root (line 179) | pub fn get_root(&self, value: Value) -> Option<Node> {
    method get_uniform (line 182) | pub fn get_uniform(&self, value: Value) -> Option<Node> {
    method iter_roots (line 186) | pub fn iter_roots<'a>(&'a self) -> impl Iterator<Item = (Value, Node)>...
    method iter_uniform_mappings (line 189) | pub fn iter_uniform_mappings<'a>(&'a self) -> impl Iterator<Item = (Va...
    method insert_scoped (line 193) | pub fn insert_scoped(&mut self, value: Value) -> Node {
    method insert_chain_entry_arg (line 205) | pub fn insert_chain_entry_arg(&mut self, chain: Chain, arg_index: usiz...
    method insert_phi (line 227) | pub fn insert_phi(&mut self, tier: usize, value: Value) -> Node {
    method phi_add_entry (line 244) | pub fn phi_add_entry(&mut self, node: Node, chain: Chain, dep: Node) {
    method insert_prim (line 253) | pub fn insert_prim(&mut self, value: Value) -> Node {
    method insert_block_capture (line 268) | pub fn insert_block_capture(&mut self, value: Value, block: Block) -> ...
    method add_dep (line 284) | pub fn add_dep(&mut self, node: Node, dep: Node, value: Value) {
    method gen_dot (line 296) | pub fn gen_dot(&self, out: &std::path::Path) {
    method chain_count (line 358) | pub fn chain_count(&self) -> usize {
    method entry_chain (line 362) | pub fn entry_chain(&mut self, arity: usize, blocks: Vec<Block>) -> Cha...
    method get_chain_entry_block (line 369) | pub fn get_chain_entry_block(&self, chain: Chain) -> Block {
    method node (line 373) | pub fn node(&self, node: Node) -> &NodeKind {
    method follow_chain (line 377) | pub fn follow_chain(&self, mut node: Node, chain: Chain) -> Node {
    method follow_chain_maybe (line 389) | pub fn follow_chain_maybe(&self, mut node: Node, chain: Chain) -> Opti...
    method dfs (line 406) | pub fn dfs(&self, start: Node, order: &mut Vec<Node>) {
    method process (line 418) | pub fn process(&mut self) {
    method propagate_graph_aliases (line 432) | fn propagate_graph_aliases(&mut self) {
    method insert_anon_phi (line 482) | fn insert_anon_phi(&mut self) -> Node {
    method remove_uniform (line 494) | pub fn remove_uniform(&mut self) {
    method expand_phis (line 529) | pub fn expand_phis(&mut self) {
    method reduce_phis2 (line 546) | pub fn reduce_phis2(&mut self) {
    method reduce_phis (line 755) | pub fn reduce_phis(&mut self) {
  type ChainData (line 105) | pub struct ChainData {
  type NodeKind (line 892) | pub enum NodeKind {
    method is_phi (line 905) | pub fn is_phi(&self) -> bool {
    method is_prim (line 911) | pub fn is_prim(&self) -> bool {
    method is_block_capture (line 917) | pub fn is_block_capture(&self) -> bool {
    method is_scope (line 923) | pub fn is_scope(&self) -> bool {
    method is_entry_arg (line 929) | pub fn is_entry_arg(&self) -> bool {
    method is_terminal (line 936) | pub fn is_terminal(&self) -> bool {
    method terminal_value (line 943) | pub fn terminal_value(&self) -> Value {
    method dependencies (line 951) | pub fn dependencies<'a>(&'a self) -> impl Iterator<Item = Node> + 'a {
  type EntryArg (line 992) | pub struct EntryArg {
  type Phi (line 1000) | pub struct Phi {
  type Prim (line 1008) | pub struct Prim {
  type BlockCapture (line 1018) | pub struct BlockCapture {

FILE: libeir_passes/src/simplify_cfg/chain_graph/synthesis/compound.rs
  type CompoundStrategy (line 9) | pub struct CompoundStrategy;
  method try_run (line 12) | fn try_run(&self, graph: &ChainGraph, fun: &Function, live: &LiveValues)...

FILE: libeir_passes/src/simplify_cfg/chain_graph/synthesis/mod.rs
  type Synthesis (line 16) | pub struct Synthesis {
    method fmt (line 33) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 54) | pub fn new() -> Self {
    method create_segment (line 72) | fn create_segment(&mut self, head: SegmentHeadKind) -> Segment {
    method create_entry_segment (line 85) | pub fn create_entry_segment(&mut self, chain: Chain, graph: &ChainGrap...
    method create_intermediate_segment (line 105) | pub fn create_intermediate_segment(&mut self) -> Segment {
    method segment (line 109) | pub fn segment<'a>(&'a mut self, segment: Segment) -> SegmentBuilder<'...
    method visit_segment (line 117) | pub fn visit_segment(&mut self, segment: Segment) {
    method substitute (line 121) | pub fn substitute(&mut self, chain: Chain, value: Value) {
    method postprocess (line 131) | pub fn postprocess(&mut self, graph: &ChainGraph) {
  type SegmentBuilder (line 182) | pub struct SegmentBuilder<'a> {
  function create_arg_instance (line 188) | fn create_arg_instance(&mut self, node: Node) -> Instance {
  function create_creation_instance (line 195) | fn create_creation_instance(&mut self, node: Node) -> Instance {
  function push_in_arg (line 202) | pub fn push_in_arg(&mut self, node: Node) -> Instance {
  function push_external (line 215) | pub fn push_external(&mut self, instance: Instance) {
  function push_instance (line 223) | pub fn push_instance(&mut self, node: Node) -> Instance {
  function push_out_arg (line 235) | pub fn push_out_arg(&mut self, instance: Instance) {
  function finish_to (line 241) | pub fn finish_to(&mut self, segment: Segment) {
  function finish_target (line 250) | pub fn finish_target(&mut self, single: bool) {
  type Instance (line 263) | pub struct Instance(u32);
  type InstanceKind (line 267) | pub enum InstanceKind {
    method is_relevant (line 283) | pub fn is_relevant(&self) -> bool {
    method node (line 289) | pub fn node(&self) -> Node {
  type Segment (line 300) | pub struct Segment(u32);
  type SegmentData (line 309) | pub struct SegmentData {
    method aux_fmt (line 338) | fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, aux: &Synthesis) ->...
  type SegmentHeadKind (line 352) | pub enum SegmentHeadKind {
    method is_intermediate (line 374) | pub fn is_intermediate(&self) -> bool {
  type SegmentBodyKind (line 383) | pub enum SegmentBodyKind {
    method aux_fmt (line 428) | fn aux_fmt(&self, f: &mut std::fmt::Formatter<'_>, aux: &Synthesis) ->...
    method is_none (line 447) | pub fn is_none(&self) -> bool {
  type SynthesisStrategy (line 455) | pub trait SynthesisStrategy {
    method try_run (line 458) | fn try_run(&self, graph: &ChainGraph, fun: &Function, live: &LiveValue...

FILE: libeir_passes/src/simplify_cfg/chain_graph/synthesis/simple.rs
  type SimpleStrategy (line 23) | pub struct SimpleStrategy;
  method try_run (line 26) | fn try_run(

FILE: libeir_passes/src/simplify_cfg/chain_graph/synthesis/single.rs
  function can_subsitute (line 5) | pub fn can_subsitute(graph: &ChainGraph, fun: &Function, chain: Chain) -...
  type SingleStrategy (line 45) | pub struct SingleStrategy;
  method try_run (line 48) | fn try_run(&self, graph: &ChainGraph, fun: &Function, _live: &LiveValues...

FILE: libeir_passes/src/simplify_cfg/chain_graph/synthesis/terminating_target.rs
  type TerminatingTargetStrategy (line 16) | pub struct TerminatingTargetStrategy;
  method try_run (line 19) | fn try_run(&self, graph: &ChainGraph, fun: &Function, live: &LiveValues)...

FILE: libeir_passes/src/simplify_cfg/mod.rs
  type BFnvHashMap (line 10) | type BFnvHashMap<'bump, K, V> = HashMap<K, V, FnvBuildHasher, &'bump Bump>;
  type SimplifyCfgPass (line 29) | pub struct SimplifyCfgPass {
    method new (line 97) | pub fn new() -> Self {
    method simplify_cfg (line 116) | fn simplify_cfg(&mut self, b: &mut FunctionBuilder) {
  method name (line 107) | fn name(&self) -> &str {
  method run_function_pass (line 110) | fn run_function_pass(&mut self, b: &mut FunctionBuilder) {

FILE: libeir_passes/src/simplify_cfg/rewrite.rs
  function rewrite (line 15) | pub fn rewrite(

FILE: libeir_passes/src/simplify_cfg/tests.rs
  function primop_in_chain (line 7) | fn primop_in_chain() {
  function double_primop_in_chain (line 44) | fn double_primop_in_chain() {
  function split_primop_in_chain (line 82) | fn split_primop_in_chain() {
  function two_split_primop_in_chain (line 133) | fn two_split_primop_in_chain() {
  function simple_tail_call_elimination (line 184) | fn simple_tail_call_elimination() {
  function tail_call_elimination (line 220) | fn tail_call_elimination() {
  function recursive_simplification (line 258) | fn recursive_simplification() {
  function value_list_removal (line 296) | fn value_list_removal() {
  function partial_loop (line 330) | fn partial_loop() {
  function tight_partial_loop (line 379) | fn tight_partial_loop() {
  function deep_primop_rename_single_branch (line 439) | fn deep_primop_rename_single_branch() {
  function deep_primop_rename_after_entry_single_branch (line 481) | fn deep_primop_rename_after_entry_single_branch() {
  function converging_from_single (line 541) | fn converging_from_single() {
  function basic_locations (line 590) | fn basic_locations() {
  function block_capture_with_scope_in_chain (line 697) | fn block_capture_with_scope_in_chain() {
  function dynamic_ops (line 727) | fn dynamic_ops() {
  function bbbb (line 787) | fn bbbb() {
  function cccc (line 942) | fn cccc() {
  function terminating_strategy_checks_live_in_outgoing (line 1108) | fn terminating_strategy_checks_live_in_outgoing() {

FILE: libeir_passes/src/util.rs
  type EdgeSet (line 4) | pub struct EdgeSet<T: Copy + Ord>(pub BTreeMap<T, T>);
  function new (line 6) | pub fn new() -> Self {
  function insert (line 9) | pub fn insert(&mut self, key: T, val: T) {
  function propagate_edges (line 12) | pub fn propagate_edges(&mut self) {
  type Walker (line 32) | pub struct Walker<T> {
  function new (line 40) | pub fn new() -> Self {
  function with (line 43) | pub fn with(to_walk: Vec<T>) -> Self {
  function clear (line 49) | pub fn clear(&mut self) {
  function put (line 53) | pub fn put(&mut self, t: T) {
  function next (line 58) | pub fn next(&mut self) -> Option<T> {

FILE: libeir_passes/src/validate.rs
  type ValidatePass (line 7) | pub struct ValidatePass {
    method new (line 12) | pub fn new() -> Self {
  method name (line 20) | fn name(&self) -> &str {
  method run_function_pass (line 23) | fn run_function_pass(&mut self, b: &mut FunctionBuilder) {

FILE: libeir_syntax_core/build.rs
  function main (line 4) | fn main() {

FILE: libeir_syntax_core/src/ast.rs
  type MapExactAssoc (line 4) | pub enum MapExactAssoc {
  type Annotated (line 10) | pub struct Annotated<I>(pub I, pub Vec<()>);
  function empty (line 12) | pub fn empty(inner: I) -> Self {
  type Module (line 18) | pub struct Module {
  type FunctionName (line 26) | pub struct FunctionName {
  type Integer (line 42) | pub struct Integer {
    method as_u32 (line 47) | pub fn as_u32(&self) -> u32 {
    method as_usize (line 51) | pub fn as_usize(&self) -> usize {
  type AtomicLiteral (line 58) | type AtomicLiteral = AtomicTerm;
  type Constant (line 79) | pub enum Constant {
  type FunctionDefinition (line 107) | pub struct FunctionDefinition {
  type SingleExpression (line 113) | pub enum SingleExpression {
  type CaseClause (line 147) | pub struct CaseClause {
  type Pattern (line 154) | pub enum Pattern {
    method nil (line 164) | pub fn nil() -> Annotated<Pattern> {
  type Expression (line 169) | pub type Expression = Annotated<Vec<Annotated<SingleExpression>>>;
    method nil (line 171) | pub fn nil() -> Self {
  type Function (line 178) | pub struct Function {
  type PrimOpCall (line 184) | pub struct PrimOpCall {

FILE: libeir_syntax_core/src/lexer.rs
  type Tok (line 10) | pub enum Tok<'input> {
  constant KEYWORDS (line 68) | const KEYWORDS: &'static [(&'static str, Tok<'static>)] = &[
  function is_escapechar (line 89) | fn is_escapechar(c: char) -> bool {
  function is_control (line 95) | fn is_control(c: char) -> bool {
  function is_inputchar (line 98) | fn is_inputchar(c: char) -> bool {
  function is_digit (line 101) | fn is_digit(c: char) -> bool {
  function is_octal (line 104) | fn is_octal(c: char) -> bool {
  function is_uppercase (line 107) | fn is_uppercase(c: char) -> bool {
  function is_lowercase (line 112) | fn is_lowercase(c: char) -> bool {
  function is_namechar (line 117) | fn is_namechar(c: char) -> bool {
  type Tokenizer (line 122) | pub struct Tokenizer<'input> {
  function new (line 130) | pub fn new(text: &'input str) -> Self {
  function bump (line 140) | fn bump(&mut self) -> Option<(usize, char)> {
  function bump_escape (line 145) | fn bump_escape(&mut self) -> Result<(), ()> {
  function take_while (line 178) | fn take_while<F>(&mut self, fun: F) -> &'input str where F: Fn(char) -> ...
  function next_token (line 201) | fn next_token(&mut self) -> Option<Result<(usize, Tok<'input>, usize), (...
  type Item (line 453) | type Item = Result<(usize, Tok<'input>, usize), ()>;
  method next (line 455) | fn next(&mut self) -> Option<Result<(usize, Tok<'input>, usize), ()>> {
  function test_symbols (line 461) | fn test_symbols() {
  function test_keywords (line 486) | fn test_keywords() {
  function test_atoms (line 503) | fn test_atoms() {
  function test_variables (line 521) | fn test_variables() {
  function test_lex_compile_core_file (line 534) | fn test_lex_compile_core_file() {

FILE: libeir_syntax_core/src/lower_hir.rs
  method from_parsed (line 12) | fn from_parsed(module: &::parser::Module) -> Self {
  method from_parsed (line 47) | fn from_parsed(fun: &::parser::Function, fun_ident: &FunctionIdent) -> S...
  function pat_node_from_parsed (line 55) | fn pat_node_from_parsed(node: &::parser::Pattern,
  method from_parsed (line 107) | fn from_parsed(pat: &::parser::Pattern,
  method from_parsed_single (line 123) | fn from_parsed_single(expr: &PSE, fun_ident: &FunctionIdent) -> SingleEx...
  method from_parsed (line 321) | fn from_parsed(fun: &::parser::Expression, fun_ident: &FunctionIdent) ->...
  function from_parsed (line 332) | pub fn from_parsed(parsed: &::parser::Module) -> Module {

FILE: libeir_syntax_core/src/parser/grammar.rs
  type __Symbol (line 34) | pub enum __Symbol<'input>
  constant __ACTION (line 109) | const __ACTION: &'static [i16] = &[
  constant __EOF_ACTION (line 853) | const __EOF_ACTION: &'static [i16] = &[
  constant __GOTO (line 1597) | const __GOTO: &'static [i16] = &[
  function __expected_tokens (line 2341) | fn __expected_tokens(__state: usize) -> Vec<::std::string::String> {
  type __StateMachine (line 2399) | pub struct __StateMachine<'input>
  type Location (line 2408) | type Location = usize;
  type Error (line 2409) | type Error = ();
  type Token (line 2410) | type Token = Tok<'input>;
  type TokenIndex (line 2411) | type TokenIndex = usize;
  type Symbol (line 2412) | type Symbol = __Symbol<'input>;
  type Success (line 2413) | type Success = Annotated<Module>;
  type StateIndex (line 2414) | type StateIndex = i16;
  type Action (line 2415) | type Action = i16;
  type ReduceIndex (line 2416) | type ReduceIndex = i16;
  type NonterminalIndex (line 2417) | type NonterminalIndex = usize;
  function start_location (line 2420) | fn start_location(&self) -> Self::Location {
  function start_state (line 2425) | fn start_state(&self) -> Self::StateIndex {
  function token_to_index (line 2430) | fn token_to_index(&self, token: &Self::Token) -> Option<usize> {
  function action (line 2435) | fn action(&self, state: i16, integer: usize) -> i16 {
  function error_action (line 2440) | fn error_action(&self, state: i16) -> i16 {
  function eof_action (line 2445) | fn eof_action(&self, state: i16) -> i16 {
  function goto (line 2450) | fn goto(&self, state: i16, nt: usize) -> i16 {
  function token_to_symbol (line 2454) | fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Sel...
  function expected_tokens (line 2458) | fn expected_tokens(&self, state: i16) -> Vec<String> {
  function uses_error_recovery (line 2463) | fn uses_error_recovery(&self) -> bool {
  function error_recovery_symbol (line 2468) | fn error_recovery_symbol(
  function reduce (line 2475) | fn reduce(
  function simulate_reduce (line 2492) | fn simulate_reduce(&self, action: i16) -> __state_machine::SimulatedRedu...
  function __token_to_integer (line 2496) | fn __token_to_integer<
  function __token_to_symbol (line 2554) | fn __token_to_symbol<
  function __simulate_reduce (line 2754) | fn __simulate_reduce<
  type AnnotatedModuleParser (line 4272) | pub struct AnnotatedModuleParser {
    method new (line 4277) | pub fn new() -> AnnotatedModuleParser {
    method parse (line 4284) | pub fn parse<
  function __reduce (line 4306) | pub(crate) fn __reduce<
  function __pop_Variant44 (line 5088) | fn __pop_Variant44<
  function __pop_Variant32 (line 5099) | fn __pop_Variant32<
  function __pop_Variant70 (line 5110) | fn __pop_Variant70<
  function __pop_Variant10 (line 5121) | fn __pop_Variant10<
  function __pop_Variant27 (line 5132) | fn __pop_Variant27<
  function __pop_Variant22 (line 5143) | fn __pop_Variant22<
  function __pop_Variant30 (line 5154) | fn __pop_Variant30<
  function __pop_Variant8 (line 5165) | fn __pop_Variant8<
  function __pop_Variant3 (line 5176) | fn __pop_Variant3<
  function __pop_Variant19 (line 5187) | fn __pop_Variant19<
  function __pop_Variant12 (line 5198) | fn __pop_Variant12<
  function __pop_Variant16 (line 5209) | fn __pop_Variant16<
  function __pop_Variant35 (line 5220) | fn __pop_Variant35<
  function __pop_Variant37 (line 5231) | fn __pop_Variant37<
  function __pop_Variant38 (line 5242) | fn __pop_Variant38<
  function __pop_Variant39 (line 5253) | fn __pop_Variant39<
  function __pop_Variant4 (line 5264) | fn __pop_Variant4<
  function __pop_Variant14 (line 5275) | fn __pop_Variant14<
  function __pop_Variant41 (line 5286) | fn __pop_Variant41<
  function __pop_Variant45 (line 5297) | fn __pop_Variant45<
  function __pop_Variant46 (line 5308) | fn __pop_Variant46<
  function __pop_Variant66 (line 5319) | fn __pop_Variant66<
  function __pop_Variant49 (line 5330) | fn __pop_Variant49<
  function __pop_Variant24 (line 5341) | fn __pop_Variant24<
  function __pop_Variant6 (line 5352) | fn __pop_Variant6<
  function __pop_Variant62 (line 5363) | fn __pop_Variant62<
  function __pop_Variant63 (line 5374) | fn __pop_Variant63<
  function __pop_Variant28 (line 5385) | fn __pop_Variant28<
  function __pop_Variant61 (line 5396) | fn __pop_Variant61<
  function __pop_Variant67 (line 5407) | fn __pop_Variant67<
  function __pop_Variant68 (line 5418) | fn __pop_Variant68<
  function __pop_Variant71 (line 5429) | fn __pop_Variant71<
  function __pop_Variant0 (line 5440) | fn __pop_Variant0<
  function __pop_Variant59 (line 5451) | fn __pop_Variant59<
  function __pop_Variant50 (line 5462) | fn __pop_Variant50<
  function __pop_Variant47 (line 5473) | fn __pop_Variant47<
  function __pop_Variant55 (line 5484) | fn __pop_Variant55<
  function __pop_Variant51 (line 5495) | fn __pop_Variant51<
  function __pop_Variant53 (line 5506) | fn __pop_Variant53<
  function __pop_Variant54 (line 5517) | fn __pop_Variant54<
  function __pop_Variant52 (line 5528) | fn __pop_Variant52<
  function __pop_Variant56 (line 5539) | fn __pop_Variant56<
  function __pop_Variant57 (line 5550) | fn __pop_Variant57<
  function __pop_Variant58 (line 5561) | fn __pop_Variant58<
  function __pop_Variant2 (line 5572) | fn __pop_Variant2<
  function __pop_Variant69 (line 5583) | fn __pop_Variant69<
  function __pop_Variant21 (line 5594) | fn __pop_Variant21<
  function __pop_Variant48 (line 5605) | fn __pop_Variant48<
  function __pop_Variant9 (line 5616) | fn __pop_Variant9<
  function __pop_Variant43 (line 5627) | fn __pop_Variant43<
  function __pop_Variant34 (line 5638) | fn __pop_Variant34<
  function __pop_Variant42 (line 5649) | fn __pop_Variant42<
  function __pop_Variant5 (line 5660) | fn __pop_Variant5<
  function __pop_Variant40 (line 5671) | fn __pop_Variant40<
  function __pop_Variant60 (line 5682) | fn __pop_Variant60<
  function __pop_Variant7 (line 5693) | fn __pop_Variant7<
  function __pop_Variant65 (line 5704) | fn __pop_Variant65<
  function __pop_Variant33 (line 5715) | fn __pop_Variant33<
  function __pop_Variant11 (line 5726) | fn __pop_Variant11<
  function __pop_Variant23 (line 5737) | fn __pop_Variant23<
  function __pop_Variant31 (line 5748) | fn __pop_Variant31<
  function __pop_Variant20 (line 5759) | fn __pop_Variant20<
  function __pop_Variant13 (line 5770) | fn __pop_Variant13<
  function __pop_Variant17 (line 5781) | fn __pop_Variant17<
  function __pop_Variant36 (line 5792) | fn __pop_Variant36<
  function __pop_Variant18 (line 5803) | fn __pop_Variant18<
  function __pop_Variant15 (line 5814) | fn __pop_Variant15<
  function __pop_Variant25 (line 5825) | fn __pop_Variant25<
  function __pop_Variant26 (line 5836) | fn __pop_Variant26<
  function __pop_Variant64 (line 5847) | fn __pop_Variant64<
  function __pop_Variant29 (line 5858) | fn __pop_Variant29<
  function __pop_Variant1 (line 5869) | fn __pop_Variant1<
  function __reduce0 (line 5880) | pub(crate) fn __reduce0<
  function __reduce1 (line 5900) | pub(crate) fn __reduce1<
  function __reduce2 (line 5920) | pub(crate) fn __reduce2<
  function __reduce3 (line 5938) | pub(crate) fn __reduce3<
  function __reduce4 (line 5958) | pub(crate) fn __reduce4<
  function __reduce5 (line 5978) | pub(crate) fn __reduce5<
  function __reduce6 (line 5996) | pub(crate) fn __reduce6<
  function __reduce7 (line 6016) | pub(crate) fn __reduce7<
  function __reduce8 (line 6036) | pub(crate) fn __reduce8<
  function __reduce9 (line 6054) | pub(crate) fn __reduce9<
  function __reduce10 (line 6076) | pub(crate) fn __reduce10<
  function __reduce11 (line 6094) | pub(crate) fn __reduce11<
  function __reduce12 (line 6113) | pub(crate) fn __reduce12<
  function __reduce13 (line 6135) | pub(crate) fn __reduce13<
  function __reduce14 (line 6158) | pub(crate) fn __reduce14<
  function __reduce15 (line 6178) | pub(crate) fn __reduce15<
  function __reduce16 (line 6196) | pub(crate) fn __reduce16<
  function __reduce17 (line 6215) | pub(crate) fn __reduce17<
  function __reduce18 (line 6235) | pub(crate) fn __reduce18<
  function __reduce19 (line 6256) | pub(crate) fn __reduce19<
  function __reduce20 (line 6276) | pub(crate) fn __reduce20<
  function __reduce21 (line 6294) | pub(crate) fn __reduce21<
  function __reduce22 (line 6313) | pub(crate) fn __reduce22<
  function __reduce23 (line 6333) | pub(crate) fn __reduce23<
  function __reduce24 (line 6354) | pub(crate) fn __reduce24<
  function __reduce25 (line 6374) | pub(crate) fn __reduce25<
  function __reduce26 (line 6392) | pub(crate) fn __reduce26<
  function __reduce27 (line 6411) | pub(crate) fn __reduce27<
  function __reduce28 (line 6431) | pub(crate) fn __reduce28<
  function __reduce29 (line 6452) | pub(crate) fn __reduce29<
  function __reduce30 (line 6472) | pub(crate) fn __reduce30<
  function __reduce31 (line 6490) | pub(crate) fn __reduce31<
  function __reduce32 (line 6509) | pub(crate) fn __reduce32<
  function __reduce33 (line 6529) | pub(crate) fn __reduce33<
  function __reduce34 (line 6550) | pub(crate) fn __reduce34<
  function __reduce35 (line 6570) | pub(crate) fn __reduce35<
  function __reduce36 (line 6588) | pub(crate) fn __reduce36<
  function __reduce37 (line 6607) | pub(crate) fn __reduce37<
  function __reduce38 (line 6627) | pub(crate) fn __reduce38<
  function __reduce39 (line 6648) | pub(crate) fn __reduce39<
  function __reduce40 (line 6669) | pub(crate) fn __reduce40<
  function __reduce41 (line 6690) | pub(crate) fn __reduce41<
  function __reduce42 (line 6708) | pub(crate) fn __reduce42<
  function __reduce43 (line 6728) | pub(crate) fn __reduce43<
  function __reduce44 (line 6746) | pub(crate) fn __reduce44<
  function __reduce45 (line 6765) | pub(crate) fn __reduce45<
  function __reduce46 (line 6785) | pub(crate) fn __reduce46<
  function __reduce47 (line 6806) | pub(crate) fn __reduce47<
  function __reduce48 (line 6826) | pub(crate) fn __reduce48<
  function __reduce49 (line 6844) | pub(crate) fn __reduce49<
  function __reduce50 (line 6863) | pub(crate) fn __reduce50<
  function __reduce51 (line 6883) | pub(crate) fn __reduce51<
  function __reduce52 (line 6904) | pub(crate) fn __reduce52<
  function __reduce53 (line 6924) | pub(crate) fn __reduce53<
  function __reduce54 (line 6942) | pub(crate) fn __reduce54<
  function __reduce55 (line 6961) | pub(crate) fn __reduce55<
  function __reduce56 (line 6981) | pub(crate) fn __reduce56<
  function __reduce57 (line 7002) | pub(crate) fn __reduce57<
  function __reduce58 (line 7023) | pub(crate) fn __reduce58<
  function __reduce59 (line 7043) | pub(crate) fn __reduce59<
  function __reduce60 (line 7061) | pub(crate) fn __reduce60<
  function __reduce61 (line 7080) | pub(crate) fn __reduce61<
  function __reduce62 (line 7100) | pub(crate) fn __reduce62<
  function __reduce63 (line 7121) | pub(crate) fn __reduce63<
  function __reduce64 (line 7142) | pub(crate) fn __reduce64<
  function __reduce65 (line 7163) | pub(crate) fn __reduce65<
  function __reduce66 (line 7185) | pub(crate) fn __reduce66<
  function __reduce67 (line 7205) | pub(crate) fn __reduce67<
  function __reduce68 (line 7223) | pub(crate) fn __reduce68<
  function __reduce69 (line 7242) | pub(crate) fn __reduce69<
  function __reduce70 (line 7262) | pub(crate) fn __reduce70<
  function __reduce71 (line 7283) | pub(crate) fn __reduce71<
  function __reduce72 (line 7304) | pub(crate) fn __reduce72<
  function __reduce73 (line 7328) | pub(crate) fn __reduce73<
  function __reduce74 (line 7347) | pub(crate) fn __reduce74<
  function __reduce75 (line 7365) | pub(crate) fn __reduce75<
  function __reduce76 (line 7384) | pub(crate) fn __reduce76<
  function __reduce77 (line 7406) | pub(crate) fn __reduce77<
  function __reduce78 (line 7425) | pub(crate) fn __reduce78<
  function __reduce79 (line 7447) | pub(crate) fn __reduce79<
  function __reduce80 (line 7465) | pub(crate) fn __reduce80<
  function __reduce81 (line 7484) | pub(crate) fn __reduce81<
  function __reduce82 (line 7503) | pub(crate) fn __reduce82<
  function __reduce83 (line 7523) | pub(crate) fn __reduce83<
  function __reduce84 (line 7542) | pub(crate) fn __reduce84<
  function __reduce85 (line 7564) | pub(crate) fn __reduce85<
  function __reduce86 (line 7583) | pub(crate) fn __reduce86<
  function __reduce87 (line 7605) | pub(crate) fn __reduce87<
  function __reduce88 (line 7624) | pub(crate) fn __reduce88<
  function __reduce89 (line 7646) | pub(crate) fn __reduce89<
  function __reduce90 (line 7667) | pub(crate) fn __reduce90<
  function __reduce91 (line 7686) | pub(crate) fn __reduce91<
  function __reduce92 (line 7705) | pub(crate) fn __reduce92<
  function __reduce93 (line 7724) | pub(crate) fn __reduce93<
  function __reduce94 (line 7745) | pub(crate) fn __reduce94<
  function __reduce95 (line 7766) | pub(crate) fn __reduce95<
  function __reduce96 (line 7789) | pub(crate) fn __reduce96<
  function __reduce97 (line 7810) | pub(crate) fn __reduce97<
  function __reduce98 (line 7834) | pub(crate) fn __reduce98<
  function __reduce99 (line 7856) | pub(crate) fn __reduce99<
  function __reduce100 (line 7878) | pub(crate) fn __reduce100<
  function __reduce101 (line 7900) | pub(crate) fn __reduce101<
  function __reduce102 (line 7924) | pub(crate) fn __reduce102<
  function __reduce103 (line 7948) | pub(crate) fn __reduce103<
  function __reduce104 (line 7974) | pub(crate) fn __reduce104<
  function __reduce105 (line 7998) | pub(crate) fn __reduce105<
  function __reduce106 (line 8017) | pub(crate) fn __reduce106<
  function __reduce107 (line 8039) | pub(crate) fn __reduce107<
  function __reduce108 (line 8058) | pub(crate) fn __reduce108<
  function __reduce109 (line 8080) | pub(crate) fn __reduce109<
  function __reduce110 (line 8099) | pub(crate) fn __reduce110<
  function __reduce111 (line 8117) | pub(crate) fn __reduce111<
  function __reduce112 (line 8136) | pub(crate) fn __reduce112<
  function __reduce113 (line 8158) | pub(crate) fn __reduce113<
  function __reduce114 (line 8177) | pub(crate) fn __reduce114<
  function __reduce115 (line 8199) | pub(crate) fn __reduce115<
  function __reduce116 (line 8218) | pub(crate) fn __reduce116<
  function __reduce117 (line 8236) | pub(crate) fn __reduce117<
  function __reduce118 (line 8255) | pub(crate) fn __reduce118<
  function __reduce119 (line 8274) | pub(crate) fn __reduce119<
  function __reduce120 (line 8293) | pub(crate) fn __reduce120<
  function __reduce121 (line 8311) | pub(crate) fn __reduce121<
  function __reduce122 (line 8330) | pub(crate) fn __reduce122<
  function __reduce123 (line 8349) | pub(crate) fn __reduce123<
  function __reduce124 (line 8367) | pub(crate) fn __reduce124<
  function __reduce125 (line 8389) | pub(crate) fn __reduce125<
  function __reduce126 (line 8408) | pub(crate) fn __reduce126<
  function __reduce127 (line 8427) | pub(crate) fn __reduce127<
  function __reduce128 (line 8446) | pub(crate) fn __reduce128<
  function __reduce129 (line 8465) | pub(crate) fn __reduce129<
  function __reduce130 (line 8484) | pub(crate) fn __reduce130<
  function __reduce131 (line 8505) | pub(crate) fn __reduce131<
  function __reduce132 (line 8528) | pub(crate) fn __reduce132<
  function __reduce133 (line 8547) | pub(crate) fn __reduce133<
  function __reduce134 (line 8565) | pub(crate) fn __reduce134<
  function __reduce135 (line 8587) | pub(crate) fn __reduce135<
  function __reduce136 (line 8608) | pub(crate) fn __reduce136<
  function __reduce137 (line 8626) | pub(crate) fn __reduce137<
  function __reduce138 (line 8648) | pub(crate) fn __reduce138<
  function __reduce139 (line 8667) | pub(crate) fn __reduce139<
  function __reduce140 (line 8686) | pub(crate) fn __reduce140<
  function __reduce141 (line 8704) | pub(crate) fn __reduce141<
  function __reduce142 (line 8724) | pub(crate) fn __reduce142<
  function __reduce143 (line 8743) | pub(crate) fn __reduce143<
  function __reduce144 (line 8762) | pub(crate) fn __reduce144<
  function __reduce145 (line 8780) | pub(crate) fn __reduce145<
  function __reduce146 (line 8800) | pub(crate) fn __reduce146<
  function __reduce147 (line 8819) | pub(crate) fn __reduce147<
  function __reduce148 (line 8838) | pub(crate) fn __reduce148<
  function __reduce149 (line 8856) | pub(crate) fn __reduce149<
  function __reduce150 (line 8876) | pub(crate) fn __reduce150<
  function __reduce151 (line 8895) | pub(crate) fn __reduce151<
  function __reduce152 (line 8914) | pub(crate) fn __reduce152<
  function __reduce153 (line 8932) | pub(crate) fn __reduce153<
  function __reduce154 (line 8952) | pub(crate) fn __reduce154<
  function __reduce155 (line 8971) | pub(crate) fn __reduce155<
  function __reduce156 (line 8990) | pub(crate) fn __reduce156<
  function __reduce157 (line 9008) | pub(crate) fn __reduce157<
  function __reduce158 (line 9028) | pub(crate) fn __reduce158<
  function __reduce159 (line 9047) | pub(crate) fn __reduce159<
  function __reduce160 (line 9066) | pub(crate) fn __reduce160<
  function __reduce161 (line 9084) | pub(crate) fn __reduce161<
  function __reduce162 (line 9104) | pub(crate) fn __reduce162<
  function __reduce163 (line 9123) | pub(crate) fn __reduce163<
  function __reduce164 (line 9142) | pub(crate) fn __reduce164<
  function __reduce165 (line 9160) | pub(crate) fn __reduce165<
  function __reduce166 (line 9180) | pub(crate) fn __reduce166<
  function __reduce167 (line 9199) | pub(crate) fn __reduce167<
  function __reduce168 (line 9218) | pub(crate) fn __reduce168<
  function __reduce169 (line 9236) | pub(crate) fn __reduce169<
  function __reduce170 (line 9256) | pub(crate) fn __reduce170<
  function __reduce171 (line 9275) | pub(crate) fn __reduce171<
  function __reduce172 (line 9294) | pub(crate) fn __reduce172<
  function __reduce173 (line 9312) | pub(crate) fn __reduce173<
  function __reduce174 (line 9332) | pub(crate) fn __reduce174<
  function __reduce175 (line 9351) | pub(crate) fn __reduce175<
  function __reduce176 (line 9370) | pub(crate) fn __reduce176<
  function __reduce177 (line 9388) | pub(crate) fn __reduce177<
  function __reduce178 (line 9408) | pub(crate) fn __reduce178<
  function __reduce179 (line 9427) | pub(crate) fn __reduce179<
  function __reduce180 (line 9448) | pub(crate) fn __reduce180<
  function __reduce181 (line 9471) | pub(crate) fn __reduce181<
  function __reduce182 (line 9492) | pub(crate) fn __reduce182<
  function __reduce183 (line 9511) | pub(crate) fn __reduce183<
  function __reduce184 (line 9530) | pub(crate) fn __reduce184<
  function __reduce185 (line 9548) | pub(crate) fn __reduce185<
  function __reduce186 (line 9571) | pub(crate) fn __reduce186<
  function __reduce187 (line 9592) | pub(crate) fn __reduce187<
  function __reduce188 (line 9613) | pub(crate) fn __reduce188<
  function __reduce189 (line 9632) | pub(crate) fn __reduce189<
  function __reduce190 (line 9651) | pub(crate) fn __reduce190<
  function __reduce191 (line 9670) | pub(crate) fn __reduce191<
  function __reduce192 (line 9689) | pub(crate) fn __reduce192<
  function __reduce193 (line 9708) | pub(crate) fn __reduce193<
  function __reduce194 (line 9726) | pub(crate) fn __reduce194<
  function __reduce195 (line 9750) | pub(crate) fn __reduce195<
  function __reduce196 (line 9771) | pub(crate) fn __reduce196<
  function __reduce197 (line 9789) | pub(crate) fn __reduce197<
  function __reduce198 (line 9808) | pub(crate) fn __reduce198<
  function __reduce199 (line 9827) | pub(crate) fn __reduce199<
  function __reduce200 (line 9847) | pub(crate) fn __reduce200<
  function __reduce201 (line 9868) | pub(crate) fn __reduce201<
  function __reduce202 (line 9887) | pub(crate) fn __reduce202<
  function __reduce203 (line 9905) | pub(crate) fn __reduce203<
  function __reduce204 (line 9925) | pub(crate) fn __reduce204<
  function __reduce205 (line 9944) | pub(crate) fn __reduce205<
  function __reduce206 (line 9968) | pub(crate) fn __reduce206<
  function __reduce207 (line 9993) | pub(crate) fn __reduce207<
  function __reduce208 (line 10014) | pub(crate) fn __reduce208<
  function __reduce209 (line 10035) | pub(crate) fn __reduce209<
  function __reduce210 (line 10056) | pub(crate) fn __reduce210<
  function __reduce211 (line 10075) | pub(crate) fn __reduce211<
  function __reduce212 (line 10094) | pub(crate) fn __reduce212<
  function __reduce213 (line 10113) | pub(crate) fn __reduce213<
  function __reduce214 (line 10134) | pub(crate) fn __reduce214<
  function __reduce215 (line 10155) | pub(crate) fn __reduce215<
  function __reduce216 (line 10178) | pub(crate) fn __reduce216<
  function __reduce217 (line 10199) | pub(crate) fn __reduce217<
  function __reduce218 (line 10220) | pub(crate) fn __reduce218<
  function __reduce219 (line 10243) | pub(crate) fn __reduce219<
  function __reduce220 (line 10262) | pub(crate) fn __reduce220<
  function __reduce221 (line 10280) | pub(crate) fn __reduce221<
  function __reduce222 (line 10301) | pub(crate) fn __reduce222<
  function __reduce223 (line 10320) | pub(crate) fn __reduce223<
  function __reduce224 (line 10341) | pub(crate) fn __reduce224<
  function __reduce225 (line 10364) | pub(crate) fn __reduce225<
  function __reduce226 (line 10385) | pub(crate) fn __reduce226<
  function __reduce227 (line 10404) | pub(crate) fn __reduce227<
  function __reduce228 (line 10426) | pub(crate) fn __reduce228<
  function __reduce229 (line 10445) | pub(crate) fn __reduce229<
  function __reduce230 (line 10464) | pub(crate) fn __reduce230<
  function __reduce231 (line 10483) | pub(crate) fn __reduce231<
  function __reduce232 (line 10504) | pub(crate) fn __reduce232<
  function __reduce233 (line 10527) | pub(crate) fn __reduce233<
  function __reduce234 (line 10548) | pub(crate) fn __reduce234<
  function __reduce235 (line 10572) | pub(crate) fn __reduce235<
  function __reduce236 (line 10597) | pub(crate) fn __reduce236<
  function __reduce237 (line 10617) | pub(crate) fn __reduce237<
  function __reduce238 (line 10639) | pub(crate) fn __reduce238<
  function __reduce239 (line 10662) | pub(crate) fn __reduce239<
  function __reduce240 (line 10685) | pub(crate) fn __reduce240<
  function __reduce241 (line 10706) | pub(crate) fn __reduce241<
  function __reduce242 (line 10729) | pub(crate) fn __reduce242<
  function __reduce243 (line 10757) | pub(crate) fn __reduce243<
  function __reduce244 (line 10780) | pub(crate) fn __reduce244<
  function __reduce245 (line 10804) | pub(crate) fn __reduce245<
  function __reduce246 (line 10823) | pub(crate) fn __reduce246<
  function __reduce247 (line 10845) | pub(crate) fn __reduce247<
  function __reduce248 (line 10866) | pub(crate) fn __reduce248<
  function __reduce249 (line 10885) | pub(crate) fn __reduce249<
  function __reduce250 (line 10904) | pub(crate) fn __reduce250<
  function __action0 (line 10929) | fn __action0<
  function __action1 (line 10940) | fn __action1<
  function __action2 (line 10957) | fn __action2<
  function __action3 (line 10968) | fn __action3<
  function __action4 (line 10979) | fn __action4<
  function __action5 (line 10990) | fn __action5<
  function __action6 (line 11012) | fn __action6<
  function __action7 (line 11025) | fn __action7<
  function __action8 (line 11038) | fn __action8<
  function __action9 (line 11051) | fn __action9<
  function __action10 (line 11064) | fn __action10<
  function __action11 (line 11080) | fn __action11<
  function __action12 (line 11091) | fn __action12<
  function __action13 (line 11102) | fn __action13<
  function __action14 (line 11113) | fn __action14<
  function __action15 (line 11124) | fn __action15<
  function __action16 (line 11137) | fn __action16<
  function __action17 (line 11151) | fn __action17<
  function __action18 (line 11162) | fn __action18<
  function __action19 (line 11176) | fn __action19<
  function __action20 (line 11187) | fn __action20<
  function __action21 (line 11198) | fn __action21<
  function __action22 (line 11209) | fn __action22<
  function __action23 (line 11222) | fn __action23<
  function __action24 (line 11236) | fn __action24<
  function __action25 (line 11252) | fn __action25<
  function __action26 (line 11270) | fn __action26<
  function __action27 (line 11282) | fn __action27<
  function __action28 (line 11297) | fn __action28<
  function __action29 (line 11312) | fn __action29<
  function __action30 (line 11325) | fn __action30<
  function __action31 (line 11340) | fn __action31<
  function __action32 (line 11361) | fn __action32<
  function __action33 (line 11378) | fn __action33<
  function __action34 (line 11389) | fn __action34<
  function __action35 (line 11403) | fn __action35<
  function __action36 (line 11417) | fn __action36<
  function __action37 (line 11429) | fn __action37<
  function __action38 (line 11440) | fn __action38<
  function __action39 (line 11453) | fn __action39<
  function __action40 (line 11464) | fn __action40<
  function __action41 (line 11477) | fn __action41<
  function __action42 (line 11488) | fn __action42<
  function __action43 (line 11501) | fn __action43<
  function __action44 (line 11512) | fn __action44<
  function __action45 (line 11525) | fn __action45<
  function __action46 (line 11536) | fn __action46<
  function __action47 (line 11547) | fn __action47<
  function __action48 (line 11558) | fn __action48<
  function __action49 (line 11571) | fn __action49<
  function __action50 (line 11584) | fn __action50<
  function __action51 (line 11598) | fn __action51<
  function __action52 (line 11611) | fn __action52<
  function __action53 (line 11626) | fn __action53<
  function __action54 (line 11639) | fn __action54<
  function __action55 (line 11654) | fn __action55<
  function __action56 (line 11667) | fn __action56<
  function __action57 (line 11681) | fn __action57<
  function __action58 (line 11692) | fn __action58<
  function __action59 (line 11703) | fn __action59<
  function __action60 (line 11714) | fn __action60<
  function __action61 (line 11725) | fn __action61<
  function __action62 (line 11736) | fn __action62<
  function __action63 (line 11749) | fn __action63<
  function __action64 (line 11763) | fn __action64<
  function __action65 (line 11777) | fn __action65<
  function __action66 (line 11788) | fn __action66<
  function __action67 (line 11800) | fn __action67<
  function __action68 (line 11812) | fn __action68<
  function __action69 (line 11828) | fn __action69<
  function __action70 (line 11844) | fn __action70<
  function __action71 (line 11860) | fn __action71<
  function __action72 (line 11871) | fn __action72<
  function __action73 (line 11883) | fn __action73<
  function __action74 (line 11895) | fn __action74<
  function __action75 (line 11911) | fn __action75<
  function __action76 (line 11922) | fn __action76<
  function __action77 (line 11936) | fn __action77<
  function __action78 (line 11947) | fn __action78<
  function __action79 (line 11961) | fn __action79<
  function __action80 (line 11977) | fn __action80<
  function __action81 (line 11988) | fn __action81<
  function __action82 (line 12000) | fn __action82<
  function __action83 (line 12013) | fn __action83<
  function __action84 (line 12024) | fn __action84<
  function __action85 (line 12038) | fn __action85<
  function __action86 (line 12050) | fn __action86<
  function __action87 (line 12061) | fn __action87<
  function __action88 (line 12072) | fn __action88<
  function __action89 (line 12086) | fn __action89<
  function __action90 (line 12102) | fn __action90<
  function __action91 (line 12113) | fn __action91<
  function __action92 (line 12127) | fn __action92<
  function __action93 (line 12140) | fn __action93<
  function __action94 (line 12151) | fn __action94<
  function __action95 (line 12163) | fn __action95<
  function __action96 (line 12175) | fn __action96<
  function __action97 (line 12191) | fn __action97<
  function __action98 (line 12207) | fn __action98<
  function __action99 (line 12218) | fn __action99<
  function __action100 (line 12232) | fn __action100<
  function __action101 (line 12243) | fn __action101<
  function __action102 (line 12257) | fn __action102<
  function __action103 (line 12273) | fn __action103<
  function __action104 (line 12284) | fn __action104<
  function __action105 (line 12298) | fn __action105<
  function __action106 (line 12309) | fn __action106<
  function __action107 (line 12323) | fn __action107<
  function __action108 (line 12334) | fn __action108<
  function __action109 (line 12348) | fn __action109<
  function __action110 (line 12364) | fn __action110<
  function __action111 (line 12377) | fn __action111<
  function __action112 (line 12393) | fn __action112<
  function __action113 (line 12405) | fn __action113<
  function __action114 (line 12416) | fn __action114<
  function __action115 (line 12427) | fn __action115<
  function __action116 (line 12441) | fn __action116<
  function __action117 (line 12452) | fn __action117<
  function __action118 (line 12464) | fn __action118<
  function __action119 (line 12475) | fn __action119<
  function __action120 (line 12487) | fn __action120<
  function __action121 (line 12499) | fn __action121<
  function __action122 (line 12510) | fn __action122<
  function __action123 (line 12522) | fn __action123<
  function __action124 (line 12533) | fn __action124<
  function __action125 (line 12545) | fn __action125<
  function __action126 (line 12557) | fn __action126<
  function __action127 (line 12568) | fn __action127<
  function __action128 (line 12580) | fn __action128<
  function __action129 (line 12591) | fn __action129<
  function __action130 (line 12603) | fn __action130<
  function __action131 (line 12615) | fn __action131<
  function __action132 (line 12626) | fn __action132<
  function __action133 (line 12638) | fn __action133<
  function __action134 (line 12649) | fn __action134<
  function __action135 (line 12661) | fn __action135<
  function __action136 (line 12673) | fn __action136<
  function __action137 (line 12684) | fn __action137<
  function __action138 (line 12696) | fn __action138<
  function __action139 (line 12707) | fn __action139<
  function __action140 (line 12719) | fn __action140<
  function __action141 (line 12731) | fn __action141<
  function __action142 (line 12742) | fn __action142<
  function __action143 (line 12754) | fn __action143<
  function __action144 (line 12765) | fn __action144<
  function __action145 (line 12777) | fn __action145<
  function __action146 (line 12789) | fn __action146<
  function __action147 (line 12800) | fn __action147<
  function __action148 (line 12812) | fn __action148<
  function __action149 (line 12823) | fn __action149<
  function __action150 (line 12835) | fn __action150<
  function __action151 (line 12846) | fn __action151<
  function __action152 (line 12858) | fn __action152<
  function __action153 (line 12870) | fn __action153<
  function __action154 (line 12881) | fn __action154<
  function __action155 (line 12893) | fn __action155<
  function __action156 (line 12904) | fn __action156<
  function __action157 (line 12916) | fn __action157<
  function __action158 (line 12928) | fn __action158<
  function __action159 (line 12939) | fn __action159<
  function __action160 (line 12951) | fn __action160<
  function __action161 (line 12962) | fn __action161<
  function __action162 (line 12974) | fn __action162<
  function __action163 (line 12986) | fn __action163<
  function __action164 (line 12997) | fn __action164<
  function __action165 (line 13009) | fn __action165<
  function __action166 (line 13020) | fn __action166<
  function __action167 (line 13032) | fn __action167<
  function __action168 (line 13044) | fn __action168<
  function __action169 (line 13055) | fn __action169<
  function __action170 (line 13067) | fn __action170<
  function __action171 (line 13078) | fn __action171<
  function __action172 (line 13090) | fn __action172<
  function __action173 (line 13102) | fn __action173<
  function __action174 (line 13113) | fn __action174<
  function __action175 (line 13125) | fn __action175<
  function __action176 (line 13136) | fn __action176<
  function __action177 (line 13148) | fn __action177<
  function __action178 (line 13159) | fn __action178<
  function __action179 (line 13171) | fn __action179<
  function __action180 (line 13182) | fn __action180<
  function __action181 (line 13194) | fn __action181<
  function __action182 (line 13205) | fn __action182<
  function __action183 (line 13217) | fn __action183<
  function __action184 (line 13228) | fn __action184<
  function __action185 (line 13240) | fn __action185<
  function __action186 (line 13251) | fn __action186<
  function __action187 (line 13263) | fn __action187<
  function __action188 (line 13274) | fn __action188<
  function __action189 (line 13286) | fn __action189<
  function __action190 (line 13297) | fn __action190<
  function __action191 (line 13309) | fn __action191<
  function __action192 (line 13320) | fn __action192<
  function __action193 (line 13332) | fn __action193<
  function __action194 (line 13343) | fn __action194<
  function __action195 (line 13355) | fn __action195<
  function __action196 (line 13366) | fn __action196<
  function __action197 (line 13378) | fn __action197<
  function __action198 (line 13401) | fn __action198<
  function __action199 (line 13430) | fn __action199<
  function __action200 (line 13457) | fn __action200<
  function __action201 (line 13480) | fn __action201<
  function __action202 (line 13509) | fn __action202<
  function __action203 (line 13536) | fn __action203<
  function __action204 (line 13565) | fn __action204<
  function __action205 (line 13592) | fn __action205<
  function __action206 (line 13615) | fn __action206<
  function __action207 (line 13644) | fn __action207<
  function __action208 (line 13671) | fn __action208<
  function __action209 (line 13700) | fn __action209<
  function __action210 (line 13727) | fn __action210<
  function __action211 (line 13754) | fn __action211<
  function __action212 (line 13779) | fn __action212<
  function __action213 (line 13806) | fn __action213<
  function __action214 (line 13835) | fn __action214<
  function __action215 (line 13858) | fn __action215<
  function __action216 (line 13881) | fn __action216<
  function __action217 (line 13904) | fn __action217<
  function __action218 (line 13929) | fn __action218<
  function __action219 (line 13952) | fn __action219<
  function __action220 (line 13975) | fn __action220<
  function __action221 (line 13998) | fn __action221<
  function __action222 (line 14023) | fn __action222<
  function __action223 (line 14046) | fn __action223<
  function __action224 (line 14069) | fn __action224<
  function __action225 (line 14092) | fn __action225<
  function __action226 (line 14117) | fn __action226<
  function __action227 (line 14140) | fn __action227<
  function __action228 (line 14163) | fn __action228<
  function __action229 (line 14186) | fn __action229<
  function __action230 (line 14211) | fn __action230<
  function __action231 (line 14234) | fn __action231<
  function __action232 (line 14257) | fn __action232<
  function __action233 (line 14280) | fn __action233<
  function __action234 (line 14305) | fn __action234<
  function __action235 (line 14328) | fn __action235<
  function __action236 (line 14351) | fn __action236<
  function __action237 (line 14376) | fn __action237<
  function __action238 (line 14399) | fn __action238<
  function __action239 (line 14426) | fn __action239<
  function __action240 (line 14449) | fn __action240<
  function __action241 (line 14472) | fn __action241<
  function __action242 (line 14497) | fn __action242<
  function __action243 (line 14520) | fn __action243<
  function __action244 (line 14543) | fn __action244<
  function __action245 (line 14566) | fn __action245<
  function __action246 (line 14591) | fn __action246<
  function __action247 (line 14614) | fn __action247<
  function __action248 (line 14637) | fn __action248<
  function __action249 (line 14660) | fn __action249<
  function __action250 (line 14685) | fn __action250<
  function __action251 (line 14708) | fn __action251<
  function __action252 (line 14731) | fn __action252<
  function __action253 (line 14756) | fn __action253<
  function __action254 (line 14787) | fn __action254<
  function __action255 (line 14810) | fn __action255<
  function __action256 (line 14835) | fn __action256<
  function __action257 (line 14858) | fn __action257<
  function __action258 (line 14881) | fn __action258<
  function __action259 (line 14906) | fn __action259<
  function __action260 (line 14933) | fn __action260<
  function __action261 (line 14956) | fn __action261<
  function __action262 (line 14981) | fn __action262<
  function __action263 (line 15004) | fn __action263<
  function __action264 (line 15027) | fn __action264<
  function __action265 (line 15048) | fn __action265<
  function __action266 (line 15071) | fn __action266<
  function __action267 (line 15094) | fn __action267<
  function __action268 (line 15117) | fn __action268<
  function __action269 (line 15146) | fn __action269<
  function __action270 (line 15175) | fn __action270<
  function __action271 (line 15206) | fn __action271<
  function __action272 (line 15237) | fn __action272<
  function __action273 (line 15258) | fn __action273<
  function __action274 (line 15281) | fn __action274<
  function __action275 (line 15304) | fn __action275<
  function __action276 (line 15327) | fn __action276<
  function __action277 (line 15348) | fn __action277<
  function __action278 (line 15371) | fn __action278<
  function __action279 (line 15394) | fn __action279<
  function __action280 (line 15417) | fn __action280<
  function __action281 (line 15438) | fn __action281<
  function __action282 (line 15461) | fn __action282<
  function __action283 (line 15484) | fn __action283<
  function __action284 (line 15507) | fn __action284<
  function __action285 (line 15528) | fn __action285<
  function __action286 (line 15551) | fn __action286<
  function __action287 (line 15574) | fn __action287<
  function __action288 (line 15597) | fn __action288<
  function __action289 (line 15618) | fn __action289<
  function __action290 (line 15641) | fn __action290<
  function __action291 (line 15664) | fn __action291<
  function __action292 (line 15687) | fn __action292<
  function __action293 (line 15708) | fn __action293<
  function __action294 (line 15731) | fn __action294<
  function __action295 (line 15754) | fn __action295<
  function __action296 (line 15777) | fn __action296<
  function __action297 (line 15798) | fn __action297<
  function __action298 (line 15821) | fn __action298<
  function __action299 (line 15844) | fn __action299<
  function __action300 (line 15867) | fn __action300<
  function __action301 (line 15900) | fn __action301<
  function __action302 (line 15933) | fn __action302<
  function __action303 (line 15954) | fn __action303<
  function __action304 (line 15977) | fn __action304<
  function __action305 (line 16000) | fn __action305<
  function __action306 (line 16023) | fn __action306<
  function __action307 (line 16048) | fn __action307<
  function __action308 (line 16069) | fn __action308<
  function __action309 (line 16090) | fn __action309<
  function __action310 (line 16111) | fn __action310<
  function __action311 (line 16136) | fn __action311<
  function __action312 (line 16161) | fn __action312<
  function __action313 (line 16190) | fn __action313<
  function __action314 (line 16215) | fn __action314<
  function __action315 (line 16246) | fn __action315<
  function __action316 (line 16273) | fn __action316<
  function __action317 (line 16300) | fn __action317<
  function __action318 (line 16327) | fn __action318<
  function __action319 (line 16358) | fn __action319<
  function __action320 (line 16389) | fn __action320<
  function __action321 (line 16424) | fn __action321<
  function __action322 (line 16455) | fn __action322<
  function __action323 (line 16476) | fn __action323<
  function __action324 (line 16499) | fn __action324<
  function __action325 (line 16522) | fn __action325<
  type __ToTriple (line 16544) | pub trait __ToTriple<'input, > {
    method to_triple (line 16545) | fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), __lalrp...
  function to_triple (line 16549) | fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), __lalrpop...
  function to_triple (line 16554) | fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), __lalrpop...

FILE: libeir_syntax_core/src/parser/mod.rs
  function parse (line 6) | pub fn parse<'input>(text: &'input str) -> Result<Annotated<Module>,

FILE: libeir_syntax_erl/build.rs
  function main (line 3) | fn main() {

FILE: libeir_syntax_erl/src/abstr/lower.rs
  function to_list_expr (line 14) | fn to_list_expr(
  function lower (line 31) | pub fn lower(root: &aast::Root) -> ast::Module {
  function lower_record_field (line 186) | fn lower_record_field(gen: &mut ast::NodeIdGenerator, tup_item: &aast::I...
  function lower_function_clause (line 205) | fn lower_function_clause(
  function lower_clause (line 237) | fn lower_clause(gen: &mut ast::NodeIdGenerator, clause: &aast::Item) -> ...
  function lower_if_clause (line 264) | fn lower_if_clause(gen: &mut ast::NodeIdGenerator, clause: &aast::Item) ...
  function lower_try_clause (line 285) | fn lower_try_clause(gen: &mut ast::NodeIdGenerator, clause: &aast::Item)...
  function lower_guards (line 335) | fn lower_guards(gen: &mut ast::NodeIdGenerator, guard: &aast::Item) -> O...
  function lower_body (line 355) | fn lower_body(gen: &mut ast::NodeIdGenerator, body: &aast::Item) -> Vec<...
  function lower_expr (line 364) | fn lower_expr(gen: &mut ast::NodeIdGenerator, expr: &aast::Item) -> ast:...
  function atom (line 812) | fn atom(item: &aast::Item) -> Ident {
  function integer (line 818) | fn integer(item: &aast::Item) -> &aast::Int {
  type ParseOrLowerError (line 835) | enum ParseOrLowerError {
    method from (line 848) | fn from(e: ParseError) -> Self {
    method from (line 853) | fn from(e: LowerError) -> Self {
  method to_diagnostic (line 840) | fn to_diagnostic(&self) -> Diagnostic {
  function parse (line 858) | fn parse<T, S>(input: S) -> T
  function parse_file (line 876) | fn parse_file<T, S>(path: S) -> T
  function basic_ast (line 895) | fn basic_ast() {
  function maps (line 924) | fn maps() {
  function match_suite (line 930) | fn match_suite() {

FILE: libeir_syntax_erl/src/evaluator.rs
  type EvalError (line 16) | pub enum EvalError {
  method to_diagnostic (line 46) | fn to_diagnostic(&self) -> Diagnostic {
  type Term (line 79) | pub enum Term {
    method from (line 136) | fn from(num: Number) -> Term {
    method from (line 141) | fn from(cond: bool) -> Term {
    method equals (line 151) | pub fn equals(&self, rhs: &Term, exact: bool) -> bool {
  method eq (line 89) | fn eq(&self, other: &Term) -> bool {
  method cmp (line 97) | fn cmp(&self, other: &Term) -> Ordering {
  method partial_cmp (line 130) | fn partial_cmp(&self, other: &Term) -> Option<Ordering> {
  type ResolveRecordIndexError (line 164) | pub enum ResolveRecordIndexError {
  function eval_expr (line 169) | pub fn eval_expr(

FILE: libeir_syntax_erl/src/lexer/errors.rs
  type LexicalError (line 12) | pub enum LexicalError {
    method span (line 78) | pub fn span(&self) -> SourceSpan {
  method hash (line 37) | fn hash<H: Hasher>(&self, state: &mut H) {
  method to_diagnostic (line 50) | fn to_diagnostic(&self) -> Diagnostic {
  type TokenConvertError (line 92) | pub struct TokenConvertError {

FILE: libeir_syntax_erl/src/lexer/lexer.rs
  type Lexer (line 63) | pub struct Lexer<S> {
  function new (line 95) | pub fn new(scanner: Scanner<S>) -> Self {
  function lex (line 109) | pub fn lex(&mut self) -> Option<<Self as Iterator>::Item> {
  function advance (line 130) | fn advance(&mut self) {
  function advance_start (line 136) | fn advance_start(&mut self) {
  function pop (line 160) | fn pop(&mut self) -> char {
  function peek (line 167) | fn peek(&mut self) -> char {
  function peek_next (line 173) | fn peek_next(&mut self) -> char {
  function read (line 179) | fn read(&mut self) -> char {
  function index (line 185) | fn index(&mut self) -> SourceIndex {
  function skip (line 190) | fn skip(&mut self) {
  function span (line 196) | pub fn span(&self) -> SourceSpan {
  function slice (line 202) | fn slice(&self) -> &str {
  function slice_span (line 207) | fn slice_span(&self, span: impl Into<Range<usize>>) -> &str {
  function skip_whitespace (line 212) | fn skip_whitespace(&mut self) {
  function tokenize (line 225) | fn tokenize(&mut self) -> Token {
  function lex_comment (line 378) | fn lex_comment(&mut self) -> Token {
  function lex_escape_sequence (line 454) | fn lex_escape_sequence(&mut self) -> Result<u64, LexicalError> {
  function lex_string (line 488) | fn lex_string(&mut self) -> Token {
  function lex_identifier (line 535) | fn lex_identifier(&mut self) -> Token {
  function lex_bare_atom (line 552) | fn lex_bare_atom(&mut self) -> Token {
  function lex_digits (line 569) | fn lex_digits(
  function lex_number (line 602) | fn lex_number(&mut self) -> Token {
  function lex_float (line 716) | fn lex_float(&mut self, num: String, seen_e: bool) -> Token {
  function to_float_literal (line 757) | fn to_float_literal(&self, num: String) -> Token {
  type Item (line 778) | type Item = Lexed;
  method next (line 780) | fn next(&mut self) -> Option<Self::Item> {
  function to_integer_literal (line 798) | fn to_integer_literal(literal: &str, radix: u32) -> Token {
  function lex_symbols (line 841) | fn lex_symbols() {
  function lex_comment (line 848) | fn lex_comment() {
  function lex_float_literal (line 860) | fn lex_float_literal() {
  function lex_identifier_or_atom (line 899) | fn lex_identifier_or_atom() {
  function lex_integer_literal (line 919) | fn lex_integer_literal() {
  function lex_string (line 991) | fn lex_string() {
  function lex_whitespace (line 1007) | fn lex_whitespace() {

FILE: libeir_syntax_erl/src/lexer/mod.rs
  type Lexed (line 16) | pub type Lexed = Result<LexicalToken, LexicalError>;
  type TokenConvertResult (line 19) | pub type TokenConvertResult<T> = Result<T, TokenConvertError>;

FILE: libeir_syntax_erl/src/lexer/token.rs
  type LexicalToken (line 12) | pub struct LexicalToken(pub SourceIndex, pub Token, pub SourceIndex);
    method token (line 15) | pub fn token(&self) -> Token {
    method span (line 20) | pub fn span(&self) -> SourceSpan {
    method fmt (line 25) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method into (line 30) | fn into(self) -> (SourceIndex, Token, SourceIndex) {
    method from (line 35) | fn from(triple: (SourceIndex, Token, SourceIndex)) -> LexicalToken {
  type TokenType (line 42) | pub enum TokenType {
    method fmt (line 50) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type AtomToken (line 62) | pub struct AtomToken(pub SourceIndex, pub Token, pub SourceIndex);
    method token (line 64) | pub fn token(&self) -> Token {
    method span (line 67) | pub fn span(&self) -> SourceSpan {
    method symbol (line 70) | pub fn symbol(&self) -> Symbol {
    type Error (line 78) | type Error = TokenConvertError;
    method try_from (line 80) | fn try_from(t: LexicalToken) -> TokenConvertResult<AtomToken> {
    method into (line 99) | fn into(self) -> LexicalToken {
    method fmt (line 104) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type IdentToken (line 110) | pub struct IdentToken(pub SourceIndex, pub Token, pub SourceIndex);
    method token (line 112) | pub fn token(&self) -> Token {
    method span (line 115) | pub fn span(&self) -> SourceSpan {
    method symbol (line 118) | pub fn symbol(&self) -> Symbol {
    type Error (line 126) | type Error = TokenConvertError;
    method try_from (line 128) | fn try_from(t: LexicalToken) -> TokenConvertResult<IdentToken> {
    method into (line 140) | fn into(self) -> LexicalToken {
    method fmt (line 145) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type StringToken (line 151) | pub struct StringToken(pub SourceIndex, pub Token, pub SourceIndex);
    method token (line 153) | pub fn token(&self) -> Token {
    method span (line 156) | pub fn span(&self) -> SourceSpan {
    method symbol (line 159) | pub fn symbol(&self) -> Symbol {
    type Error (line 167) | type Error = TokenConvertError;
    method try_from (line 169) | fn try_from(t: LexicalToken) -> TokenConvertResult<StringToken> {
    method into (line 181) | fn into(self) -> LexicalToken {
    method fmt (line 186) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type IntegerToken (line 192) | pub struct IntegerToken(pub SourceIndex, pub Token, pub SourceIndex);
    method token (line 194) | pub fn token(&self) -> Token {
    method span (line 197) | pub fn span(&self) -> SourceSpan {
    method small_integer (line 200) | pub fn small_integer(&self) -> Option<i64> {
    type Error (line 208) | type Error = TokenConvertError;
    method try_from (line 210) | fn try_from(t: LexicalToken) -> TokenConvertResult<Self> {
    method into (line 222) | fn into(self) -> LexicalToken {
    method fmt (line 227) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type SymbolToken (line 233) | pub struct SymbolToken(pub SourceIndex, pub Token, pub SourceIndex);
    method token (line 235) | pub fn token(&self) -> Token {
    method span (line 238) | pub fn span(&self) -> SourceSpan {
    type Error (line 243) | type Error = TokenConvertError;
    method try_from (line 245) | fn try_from(t: LexicalToken) -> TokenConvertResult<SymbolToken> {
    method into (line 260) | fn into(self) -> LexicalToken {
    method fmt (line 265) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type DelayedSubstitution (line 271) | pub enum DelayedSubstitution {
  type Token (line 278) | pub enum Token {
    method from_bare_atom (line 456) | pub fn from_bare_atom<'input>(atom: &'input str) -> Self {
    method get_closing_token (line 490) | pub fn get_closing_token(&self) -> Self {
    method fmt (line 502) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 398) | fn eq(&self, other: &Token) -> bool {
  method hash (line 442) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: libeir_syntax_erl/src/lib.rs
  type ErlangError (line 18) | pub enum ErlangError {
    method from (line 23) | fn from(e: ParserError) -> Self {
    method from (line 28) | fn from(e: LowerError) -> Self {
    method to_diagnostic (line 33) | fn to_diagnostic(&self) -> libeir_diagnostics::Diagnostic {

FILE: libeir_syntax_erl/src/lower/errors.rs
  type LowerError (line 10) | pub enum LowerError {
    method from (line 114) | fn from(err: crate::util::string_tokenizer::StringTokenizeError) -> Se...
    method from (line 119) | fn from(err: StringError) -> LowerError {
  method to_diagnostic (line 125) | fn to_diagnostic(&self) -> Diagnostic {

FILE: libeir_syntax_erl/src/lower/exception_handler_stack.rs
  type ExceptionHandlerStack (line 4) | pub struct ExceptionHandlerStack {
    method new (line 8) | pub fn new() -> Self {
    method push_handler (line 12) | pub fn push_handler(&mut self, handler: Value) {
    method pop_handler (line 16) | pub fn pop_handler(&mut self) {
    method make_error_jump_trace (line 20) | pub fn make_error_jump_trace(
    method make_error_jump (line 36) | pub fn make_error_jump(
    method finish (line 53) | pub fn finish(&self) {
    method len (line 57) | pub fn len(&self) -> usize {

FILE: libeir_syntax_erl/src/lower/expr/binary.rs
  function make_size (line 19) | fn make_size(
  function lower_binary_elem (line 60) | pub(crate) fn lower_binary_elem(
  function lower_binary_expr (line 115) | pub(super) fn lower_binary_expr(

FILE: libeir_syntax_erl/src/lower/expr/binary_expr.rs
  function lower_binary_expr (line 11) | pub(super) fn lower_binary_expr(

FILE: libeir_syntax_erl/src/lower/expr/case.rs
  function lower_case_expr (line 13) | pub(super) fn lower_case_expr(
  function lower_if_expr (line 86) | pub(super) fn lower_if_expr(

FILE: libeir_syntax_erl/src/lower/expr/catch.rs
  function lower_try_expr (line 15) | pub(super) fn lower_try_expr(
  function lower_catch_expr (line 196) | pub(super) fn lower_catch_expr(

FILE: libeir_syntax_erl/src/lower/expr/comprehension.rs
  type ComprehensionError (line 24) | pub enum ComprehensionError {
  function make_head_pattern (line 31) | fn make_head_pattern(
  function make_structural_bin_pattern (line 79) | fn make_structural_bin_pattern(
  function lower_qual (line 91) | fn lower_qual<F>(
  function lower_list_comprehension_expr (line 343) | pub(super) fn lower_list_comprehension_expr(
  function lower_binary_comprehension_expr (line 371) | pub(super) fn lower_binary_comprehension_expr(

FILE: libeir_syntax_erl/src/lower/expr/literal.rs
  function lower_literal (line 12) | pub(super) fn lower_literal(
  function intern_string_const (line 34) | pub fn intern_string_const(ident: Ident, c: &mut ConstantContainer) -> R...

FILE: libeir_syntax_erl/src/lower/expr/map.rs
  function lower_map_update_expr (line 11) | pub(super) fn lower_map_update_expr(
  function lower_map_expr (line 30) | pub(super) fn lower_map_expr(
  function lower (line 55) | fn lower(

FILE: libeir_syntax_erl/src/lower/expr/mod.rs
  function lower_block (line 33) | pub(super) fn lower_block<'a, T>(
  function lower_block_same_scope (line 69) | pub(super) fn lower_block_same_scope<'a, T>(
  function lower_single (line 92) | pub(super) fn lower_single(
  function lower_single_same_scope (line 106) | pub(super) fn lower_single_same_scope(
  function lower_expr (line 118) | fn lower_expr(

FILE: libeir_syntax_erl/src/lower/expr/receive.rs
  function lower_receive (line 13) | pub(super) fn lower_receive(

FILE: libeir_syntax_erl/src/lower/expr/record.rs
  function make_rec_fail (line 11) | fn make_rec_fail(
  function lower_record_access_expr (line 31) | pub(super) fn lower_record_access_expr(
  function lower_record_update_expr (line 65) | pub(super) fn lower_record_update_expr(
  function lower_record_expr (line 122) | pub(super) fn lower_record_expr(
  function lower_record_index (line 181) | pub(super) fn lower_record_index(

FILE: libeir_syntax_erl/src/lower/mod.rs
  type LowerCtx (line 41) | pub(crate) struct LowerCtx<'a> {
  function sentinel (line 71) | pub fn sentinel(&self) -> IrValue {
  function error (line 75) | pub fn error(&mut self, err: LowerError) {
  function warn (line 79) | pub fn warn(&mut self, err: LowerError) {
  function failed (line 83) | pub fn failed(&self) -> bool {
  function make_unique (line 87) | pub fn make_unique(&mut self) -> usize {
  function resolve_rec_idx (line 93) | pub fn resolve_rec_idx(&self, name: Ident, field: Ident) -> Result<usize...
  function resolve (line 106) | pub fn resolve(&mut self, ident: Ident) -> IrValue {
  function bind_shadow (line 116) | pub fn bind_shadow(&mut self, ident: Ident, val: IrValue) {
  function bind (line 125) | pub fn bind(&mut self, ident: Ident, val: IrValue) {
  function function_name (line 134) | pub fn function_name(&self) -> String {
  function current_location (line 137) | pub fn current_location(&self, b: &mut FunctionBuilder, span: SourceSpan...
  function call_function (line 146) | pub fn call_function<M, F>(
  function lower_module (line 184) | pub fn lower_module<'a>(
  function lower_function (line 242) | fn lower_function(ctx: &mut LowerCtx, b: &mut FunctionBuilder, fun: &Fun...
  function lower_function_base (line 267) | fn lower_function_base(
  function lower_top_function (line 364) | fn lower_top_function(ctx: &mut LowerCtx, b: &mut FunctionBuilder, funct...

FILE: libeir_syntax_erl/src/lower/pattern/mod.rs
  type EqGuard (line 19) | enum EqGuard {
  type ClauseLowerCtx (line 24) | struct ClauseLowerCtx {
    method clause_value (line 52) | pub fn clause_value(&mut self, pat: &mut PatternContainer, val: IrValu...
    method lower_guard (line 197) | fn lower_guard(
  type LoweredClause (line 62) | pub(crate) struct LoweredClause {
    method make_body (line 71) | pub fn make_body(&self, ctx: &mut LowerCtx, b: &mut FunctionBuilder) -...
  type UnreachableClause (line 90) | pub(crate) struct UnreachableClause {
    method make_body (line 95) | pub fn make_body(&self, ctx: &mut LowerCtx, b: &mut FunctionBuilder) -...
  function lower_clause (line 115) | pub(super) fn lower_clause<'a, P>(

FILE: libeir_syntax_erl/src/lower/pattern/tree/from_expr.rs
  function pattern_to_tree_node_append_tail (line 24) | fn pattern_to_tree_node_append_tail(
  method add_root (line 81) | pub(crate) fn add_root(
  function pattern_to_tree_node (line 93) | fn pattern_to_tree_node(

FILE: libeir_syntax_erl/src/lower/pattern/tree/lower.rs
  method lower (line 13) | pub(in super::super) fn lower(
  method pseudo_binds (line 74) | pub fn pseudo_binds(&self) -> Vec<Ident> {
  function create_nodes (line 84) | fn create_nodes(
  function lower_tree_node (line 125) | fn lower_tree_node(

FILE: libeir_syntax_erl/src/lower/pattern/tree/merge.rs
  function merge_tree_nodes (line 12) | pub(crate) fn merge_tree_nodes(ctx: &mut LowerCtx, b: &mut FunctionBuild...
  function map_node (line 21) | fn map_node(ctx: &mut LowerCtx, b: &mut FunctionBuilder, t: &mut Tree, n...
  function merge_nodes (line 94) | fn merge_nodes(

FILE: libeir_syntax_erl/src/lower/pattern/tree/mod.rs
  type Tree (line 28) | pub(crate) struct Tree {
    method new (line 41) | pub fn new() -> Self {
    method process (line 56) | pub fn process(&mut self, ctx: &mut LowerCtx, b: &mut FunctionBuilder,...
    method node_span (line 61) | pub fn node_span(&self, node: TreeNode) -> SourceSpan {
    method rename (line 74) | fn rename(&mut self, from: TreeNode, to: TreeNode) {
  type TreeNode (line 87) | pub(crate) struct TreeNode(u32);
  type TreeNodeKind (line 91) | pub(crate) enum TreeNodeKind {
  type ConstraintKind (line 129) | pub(crate) enum ConstraintKind {
    method constant (line 136) | fn constant(&self) -> Option<Const> {
    method primop (line 143) | fn primop(&self) -> Option<PrimOp> {
    method value (line 150) | fn value(&self) -> Option<IrValue> {

FILE: libeir_syntax_erl/src/lower/pattern/tree/promote_values.rs
  type PromoteCtx (line 15) | struct PromoteCtx<'a, 'b> {
  function resolve_or_bind (line 22) | fn resolve_or_bind(
  function resolve_only (line 52) | fn resolve_only(&self, ident: Ident) -> Option<Either<TreeNode, IrValue>> {
  function bind (line 64) | fn bind(&mut self, ident: Ident, node: TreeNode) -> Option<TreeNode> {
  function promote_values (line 79) | pub(crate) fn promote_values(
  function process_constants_node (line 106) | fn process_constants_node(
  function promote_values_node (line 129) | fn promote_values_node(

FILE: libeir_syntax_erl/src/lower/scope.rs
  function is_wildcard (line 11) | pub fn is_wildcard(ident: Ident) -> bool {
  type ScopeToken (line 15) | pub struct ScopeToken {
  type ScopeTracker (line 21) | pub struct ScopeTracker {
    method new (line 28) | pub fn new() -> Self {
    method push (line 36) | pub fn push(&mut self) -> ScopeToken {
    method pop (line 46) | pub fn pop(&mut self, token: ScopeToken) {
    method pop_take (line 53) | pub fn pop_take(&mut self, token: ScopeToken) -> HashMap<Ident, IrValu...
    method resolve (line 68) | pub fn resolve(&self, ident: Ident) -> Result<IrValue, LowerError> {
    method bind (line 76) | pub fn bind(&mut self, ident: Ident, val: IrValue) -> Result<(), Lower...
    method bind_shadow (line 92) | pub fn bind_shadow(&mut self, ident: Ident, val: IrValue) -> Result<()...
    method height (line 109) | pub fn height(&self) -> usize {
  type Branch (line 115) | struct Branch {
  type ScopeMerge (line 126) | pub(super) struct ScopeMerge {
    method new (line 131) | pub fn new() -> Self {
    method branch (line 137) | pub fn branch(&mut self, cont: IrBlock, ret: IrValue, binds: HashMap<I...
    method finish (line 145) | pub fn finish(&mut self, ctx: &mut LowerCtx, b: &mut FunctionBuilder) ...

FILE: libeir_syntax_erl/src/lower/tests.rs
  function parse (line 13) | fn parse<T, S>(input: S, config: ParseConfig, codemap: Arc<CodeMap>) -> T
  function lower (line 28) | fn lower(input: &str, config: ParseConfig) -> Result<IrModule, ()> {
  function fib_lower (line 40) | fn fib_lower() {
  function pat_1_lower (line 53) | fn pat_1_lower() {
  function spec_named_return_type (line 66) | fn spec_named_return_type() {
  function delayed_substitution_macros (line 79) | fn delayed_substitution_macros() {

FILE: libeir_syntax_erl/src/parser/ast/attributes.rs
  type TypeDef (line 22) | pub struct TypeDef {
  method eq (line 30) | fn eq(&self, other: &Self) -> bool {
  type TypeSpec (line 67) | pub struct TypeSpec {
  method eq (line 74) | fn eq(&self, other: &Self) -> bool {
  type Callback (line 83) | pub struct Callback {
  method eq (line 91) | fn eq(&self, other: &Self) -> bool {
  type TypeSig (line 101) | pub struct TypeSig {
  type TypeGuard (line 110) | pub struct TypeGuard {
  method eq (line 116) | fn eq(&self, other: &TypeGuard) -> bool {
  type UserAttribute (line 129) | pub struct UserAttribute {
  method eq (line 135) | fn eq(&self, other: &Self) -> bool {
  type Deprecation (line 142) | pub enum Deprecation {
    method span (line 154) | pub fn span(&self) -> SourceSpan {
  method eq (line 162) | fn eq(&self, other: &Self) -> bool {
  method hash (line 181) | fn hash<H: Hasher>(&self, state: &mut H) {
  type DeprecatedFlag (line 192) | pub enum DeprecatedFlag {
    method fmt (line 199) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Attribute (line 211) | pub enum Attribute {
  method eq (line 228) | fn eq(&self, other: &Attribute) -> bool {

FILE: libeir_syntax_erl/src/parser/ast/expr.rs
  type Expr (line 15) | pub enum Expr {
    method span (line 55) | pub fn span(&self) -> SourceSpan {
    method id (line 90) | pub fn id(&self) -> NodeId {
  type Var (line 128) | pub struct Var(pub NodeId, pub Ident);
  method eq (line 130) | fn eq(&self, other: &Self) -> bool {
  type Nil (line 137) | pub struct Nil(pub SourceSpan, pub NodeId);
  method eq (line 139) | fn eq(&self, _: &Self) -> bool {
  type Cons (line 146) | pub struct Cons {
  method eq (line 153) | fn eq(&self, other: &Self) -> bool {
  type Tuple (line 167) | pub struct Tuple {
  method eq (line 173) | fn eq(&self, other: &Self) -> bool {
  type Map (line 184) | pub struct Map {
  method eq (line 190) | fn eq(&self, other: &Self) -> bool {
  type MapUpdate (line 202) | pub struct MapUpdate {
  method eq (line 209) | fn eq(&self, other: &Self) -> bool {
  type MapProjection (line 216) | pub struct MapProjection {
  method eq (line 223) | fn eq(&self, other: &Self) -> bool {
  type Literal (line 235) | pub enum Literal {
    method span (line 243) | pub fn span(&self) -> SourceSpan {
    method id (line 252) | pub fn id(&self) -> NodeId {
  method eq (line 263) | fn eq(&self, other: &Literal) -> bool {
  method partial_cmp (line 277) | fn partial_cmp(&self, other: &Literal) -> Option<Ordering> {
  type MapField (line 316) | pub enum MapField {
    method key (line 331) | pub fn key(&self) -> Expr {
    method value (line 338) | pub fn value(&self) -> Expr {
    method span (line 345) | pub fn span(&self) -> SourceSpan {
  method eq (line 353) | fn eq(&self, other: &Self) -> bool {
  type Record (line 368) | pub struct Record {
  method eq (line 375) | fn eq(&self, other: &Self) -> bool {
  type RecordAccess (line 382) | pub struct RecordAccess {
  method eq (line 390) | fn eq(&self, other: &Self) -> bool {
  type RecordIndex (line 397) | pub struct RecordIndex {
  method eq (line 404) | fn eq(&self, other: &Self) -> bool {
  type RecordUpdate (line 411) | pub struct RecordUpdate {
  method eq (line 419) | fn eq(&self, other: &Self) -> bool {
  type RecordField (line 429) | pub struct RecordField {
  method eq (line 437) | fn eq(&self, other: &Self) -> bool {
  type Binary (line 443) | pub struct Binary {
  method eq (line 449) | fn eq(&self, other: &Self) -> bool {
  type BinaryElement (line 457) | pub struct BinaryElement {
  method eq (line 465) | fn eq(&self, other: &Self) -> bool {
  type BitType (line 474) | pub enum BitType {
    method span (line 479) | pub fn span(&self) -> SourceSpan {
  method eq (line 487) | fn eq(&self, other: &Self) -> bool {
  type ListComprehension (line 499) | pub struct ListComprehension {
  method eq (line 506) | fn eq(&self, other: &Self) -> bool {
  type BinaryComprehension (line 512) | pub struct BinaryComprehension {
  method eq (line 519) | fn eq(&self, other: &Self) -> bool {
  type Generator (line 526) | pub struct Generator {
  method eq (line 533) | fn eq(&self, other: &Self) -> bool {
  type BinaryGenerator (line 540) | pub struct BinaryGenerator {
  method eq (line 547) | fn eq(&self, other: &Self) -> bool {
  type Begin (line 554) | pub struct Begin {
  method eq (line 560) | fn eq(&self, other: &Self) -> bool {
  type Apply (line 567) | pub struct Apply {
  method eq (line 574) | fn eq(&self, other: &Self) -> bool {
  type Remote (line 581) | pub struct Remote {
  method eq (line 588) | fn eq(&self, other: &Self) -> bool {
  type BinaryExpr (line 594) | pub struct BinaryExpr {
  method eq (line 602) | fn eq(&self, other: &Self) -> bool {
  type UnaryExpr (line 608) | pub struct UnaryExpr {
  method eq (line 615) | fn eq(&self, other: &Self) -> bool {
  type Match (line 621) | pub struct Match {
  method eq (line 628) | fn eq(&self, other: &Self) -> bool {
  type If (line 634) | pub struct If {
  method eq (line 640) | fn eq(&self, other: &Self) -> bool {
  type IfClause (line 647) | pub struct IfClause {
  method eq (line 654) | fn eq(&self, other: &Self) -> bool {
  type Catch (line 660) | pub struct Catch {
  method eq (line 666) | fn eq(&self, other: &Self) -> bool {
  type Case (line 672) | pub struct Case {
  method eq (line 679) | fn eq(&self, other: &Self) -> bool {
  type Receive (line 685) | pub struct Receive {
  method eq (line 692) | fn eq(&self, other: &Self) -> bool {
  type Try (line 698) | pub struct Try {
  method eq (line 707) | fn eq(&self, other: &Self) -> bool {
  type TryClause (line 717) | pub struct TryClause {
  method eq (line 727) | fn eq(&self, other: &Self) -> bool {
  type After (line 738) | pub struct After {
  method eq (line 745) | fn eq(&self, other: &Self) -> bool {
  type Clause (line 752) | pub struct Clause {
  method eq (line 760) | fn eq(&self, other: &Self) -> bool {

FILE: libeir_syntax_erl/src/parser/ast/functions.rs
  type LocalFunctionName (line 14) | pub struct LocalFunctionName {
  method eq (line 20) | fn eq(&self, other: &Self) -> bool {
  method hash (line 26) | fn hash<H: Hasher>(&self, state: &mut H) {
  method partial_cmp (line 32) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 42) | fn cmp(&self, other: &Self) -> Ordering {
  type ResolvedFunctionName (line 49) | pub struct ResolvedFunctionName {
    method to_local (line 89) | pub fn to_local(&self) -> LocalFunctionName {
  method eq (line 57) | fn eq(&self, other: &Self) -> bool {
  method hash (line 63) | fn hash<H: Hasher>(&self, state: &mut H) {
  method partial_cmp (line 70) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 83) | fn cmp(&self, other: &Self) -> Ordering {
  type PartiallyResolvedFunctionName (line 101) | pub struct PartiallyResolvedFunctionName {
    method resolve (line 108) | pub fn resolve(&self, module: Ident) -> ResolvedFunctionName {
    method to_local (line 142) | pub fn to_local(&self) -> LocalFunctionName {
  method eq (line 119) | fn eq(&self, other: &Self) -> bool {
  method hash (line 125) | fn hash<H: Hasher>(&self, state: &mut H) {
  method partial_cmp (line 131) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  type UnresolvedFunctionName (line 155) | pub struct UnresolvedFunctionName {
  method eq (line 163) | fn eq(&self, other: &Self) -> bool {
  method hash (line 169) | fn hash<H: Hasher>(&self, state: &mut H) {
  method partial_cmp (line 176) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  type FunctionName (line 188) | pub enum FunctionName {
    method span (line 194) | pub fn span(&self) -> SourceSpan {
    method id (line 203) | pub fn id(&self) -> NodeId {
    method detect (line 211) | pub fn detect(
    method from_clause (line 257) | pub fn from_clause(nid: &mut NodeIdGenerator, clause: &FunctionClause)...
    method fmt (line 275) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type NamedFunction (line 304) | pub struct NamedFunction {
    method new (line 321) | pub fn new(
  method eq (line 313) | fn eq(&self, other: &Self) -> bool {
  type Lambda (line 424) | pub struct Lambda {
    method new (line 436) | pub fn new(
  method eq (line 431) | fn eq(&self, other: &Self) -> bool {
  type Function (line 502) | pub enum Function {
    method span (line 507) | pub fn span(&self) -> SourceSpan {
    method id (line 513) | pub fn id(&self) -> NodeId {
    method new (line 520) | pub fn new(
  type FunctionClause (line 539) | pub struct FunctionClause {
    method new (line 555) | pub fn new(
  method eq (line 547) | fn eq(&self, other: &FunctionClause) -> bool {
  type Guard (line 573) | pub struct Guard {
  method eq (line 578) | fn eq(&self, other: &Guard) -> bool {

FILE: libeir_syntax_erl/src/parser/ast/mod.rs
  type TryParseResult (line 21) | pub type TryParseResult<T> =
  type Name (line 27) | pub enum Name {
    method symbol (line 32) | pub fn symbol(&self) -> Symbol {
    method span (line 38) | pub fn span(&self) -> SourceSpan {
    method atom (line 44) | pub fn atom(&self) -> Ident {
    method var (line 50) | pub fn var(&self) -> Ident {
  method partial_cmp (line 58) | fn partial_cmp(&self, other: &Name) -> Option<std::cmp::Ordering> {
  type Arity (line 64) | pub enum Arity {
  type NodeId (line 70) | pub struct NodeId(pub usize);
  type NodeIdGenerator (line 73) | pub struct NodeIdGenerator(usize);
    method new (line 75) | pub fn new() -> Self {
    method next (line 79) | pub fn next(&mut self) -> NodeId {
  type BinaryOp (line 87) | pub enum BinaryOp {
  type UnaryOp (line 126) | pub enum UnaryOp {

FILE: libeir_syntax_erl/src/parser/ast/module.rs
  type TopLevel (line 23) | pub enum TopLevel {
  type DefinedRecord (line 30) | pub struct DefinedRecord {
  method eq (line 35) | fn eq(&self, other: &Self) -> bool {
  type Module (line 52) | pub struct Module {
    method new (line 89) | pub fn new(
    method add_auto_imports (line 753) | fn add_auto_imports(&mut self, nid: &mut NodeIdGenerator) {
    method define_pseudolocals (line 954) | fn define_pseudolocals(&mut self, nid: &mut NodeIdGenerator) {
    method define_function (line 1005) | fn define_function(&mut self, f: NamedFunction) {
  method eq (line 1017) | fn eq(&self, other: &Module) -> bool {
  type CompileOptions (line 1063) | pub struct CompileOptions {
    method from_expr (line 1152) | pub fn from_expr(module: &Ident, expr: &Expr) -> (Self, Vec<Diagnostic...
    method merge_from_expr (line 1160) | pub fn merge_from_expr(&mut self, module: &Ident, expr: &Expr) -> Resu...
    method set_option (line 1164) | fn set_option(&mut self, module: &Ident, expr: &Expr) -> Result<(), Ve...
    method compiler_opts_from_list (line 1332) | fn compiler_opts_from_list(
    method no_auto_imports (line 1346) | fn no_auto_imports(
    method no_warn_unused_functions (line 1390) | fn no_warn_unused_functions(
    method inline_functions (line 1416) | fn inline_functions(
  method default (line 1114) | fn default() -> Self {
  function to_list_simple (line 1460) | fn to_list_simple(mut expr: &Expr) -> Vec<Expr> {
  function to_list (line 1479) | fn to_list(head: &Expr, tail: &Expr) -> Vec<Expr> {

FILE: libeir_syntax_erl/src/parser/ast/types.rs
  type Type (line 62) | pub enum Type {
    method union (line 122) | pub fn union(span: SourceSpan, lhs: Type, rhs: Type) -> Self {
    method is_builtin_type (line 135) | pub fn is_builtin_type(&self) -> bool {
  method eq (line 165) | fn eq(&self, other: &Type) -> bool {

FILE: libeir_syntax_erl/src/parser/binary.rs
  type TypeName (line 8) | pub enum TypeName {
    method fmt (line 18) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  function default_specifier (line 31) | pub fn default_specifier() -> BinaryEntrySpecifier {
  type SpecifierError (line 40) | pub enum SpecifierError {
  method to_diagnostic (line 63) | fn to_diagnostic(&self) -> Diagnostic {
  function specifier_from_parsed (line 116) | pub fn specifier_from_parsed(parsed: &[BitType], has_size: bool) -> Resu...
  function specifier_to_typename (line 265) | pub fn specifier_to_typename(specifier: &BinaryEntrySpecifier) -> TypeNa...
  function specifier_can_have_size (line 277) | pub fn specifier_can_have_size(specifier: &BinaryEntrySpecifier) -> bool {

FILE: libeir_syntax_erl/src/parser/errors.rs
  type ParseError (line 10) | pub type ParseError = lalrpop_util::ParseError<SourceIndex, Token, ()>;
  type ParserError (line 13) | pub enum ParserError {
    method from (line 49) | fn from(err: Diagnostic) -> Self {
    method from (line 57) | fn from(err: ParseError) -> Self {
    method from (line 123) | fn from(source: SourceError) -> Self {
    method from (line 128) | fn from(source: PreprocessorError) -> Self {
  method to_diagnostic (line 78) | fn to_diagnostic(&self) -> Diagnostic {

FILE: libeir_syntax_erl/src/parser/mod.rs
  type ParserErrorReceiver (line 16) | type ParserErrorReceiver<'a> = dyn ErrorReceiver<E = ParserError, W = Pa...
  type Parser (line 49) | pub type Parser = GParser<ParseConfig>;
  type ParseResult (line 59) | pub type ParseResult<T> = Result<T, Vec<ParserError>>;
  type ParseConfig (line 62) | pub struct ParseConfig {
    method new (line 70) | pub fn new() -> Self {
  method default (line 75) | fn default() -> Self {
  type Parser (line 87) | type Parser = grammar::ModuleParser;
  type Error (line 88) | type Error = ParserError;
  type Config (line 89) | type Config = ParseConfig;
  type Token (line 90) | type Token = Preprocessed;
  method root_file_error (line 92) | fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> ...
  method parse (line 96) | fn parse<'a, S>(
  method parse_tokens (line 114) | fn parse_tokens<'a, S: IntoIterator<Item = Preprocessed>>(
  type Parser (line 125) | type Parser = grammar::ExprParser;
  type Error (line 126) | type Error = ParserError;
  type Config (line 127) | type Config = ParseConfig;
  type Token (line 128) | type Token = Preprocessed;
  method root_file_error (line 130) | fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> ...
  method parse (line 134) | fn parse<S>(parser: &Parser, err: &mut ParserErrorReceiver, source: S) -...
  method parse_tokens (line 148) | fn parse_tokens<S: IntoIterator<Item = Preprocessed>>(
  function to_parse_result (line 158) | fn to_parse_result<T>(
  function fail_with (line 192) | fn fail_with<E, W>(errors: &Errors<E, W>, codemap: &CodeMap, message: &'...
  function parse (line 207) | fn parse<T, S>(config: ParseConfig, codemap: Arc<CodeMap>, input: S) -> T
  function parse_fail (line 220) | fn parse_fail<T, S>(
  function parse_empty_module (line 249) | fn parse_empty_module() {
  function parse_module_with_multi_clause_function (line 259) | fn parse_module_with_multi_clause_function() {
  function parse_if_expressions (line 309) | fn parse_if_expressions() {
  function parse_case_expressions (line 408) | fn parse_case_expressions() {
  function parse_receive_expressions (line 489) | fn parse_receive_expressions() {
  function parse_preprocessor_if (line 591) | fn parse_preprocessor_if() {
  function parse_preprocessor_warning_error (line 666) | fn parse_preprocessor_warning_error() {
  function parse_try (line 706) | fn parse_try() {
  function parse_try2 (line 794) | fn parse_try2() {
  function parse_numbers (line 825) | fn parse_numbers() {
  function parse_spec (line 839) | fn parse_spec() {
  function parse_binary_spec_constant (line 852) | fn parse_binary_spec_constant() {
  function parse_multi_line_string (line 865) | fn parse_multi_line_string() {
  function parse_multi_line_record (line 880) | fn parse_multi_line_record() {
  function parse_removed_attribute (line 895) | fn parse_removed_attribute() {
  function parse_on_load (line 907) | fn parse_on_load() {
  function parse_elixir_enum_erl (line 920) | fn parse_elixir_enum_erl() {

FILE: libeir_syntax_erl/src/preprocessor/directive.rs
  type Directive (line 14) | pub enum Directive {
    method span (line 31) | pub fn span(&self) -> SourceSpan {
    method fmt (line 51) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method try_read_from (line 71) | fn try_read_from<R, S>(reader: &mut R) -> Result<Option<Self>>

FILE: libeir_syntax_erl/src/preprocessor/directives.rs
  type IncludeLibErrorVariant (line 19) | pub enum IncludeLibErrorVariant {
  type DirectiveError (line 27) | pub enum DirectiveError {
    method to_diagnostic (line 48) | pub fn to_diagnostic(&self) -> Diagnostic {
  type DirectiveResult (line 120) | type DirectiveResult<T> = std::result::Result<T, DirectiveError>;
  type Module (line 126) | pub struct Module {
    method span (line 135) | pub fn span(&self) -> SourceSpan {
    method expand (line 141) | pub fn expand(&self) -> VecDeque<LexicalToken> {
    method fmt (line 161) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 156) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 166) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  function do_include (line 181) | fn do_include(subs_path: &PathBuf, include_paths: &VecDeque<PathBuf>) ->...
  type Include (line 208) | pub struct Include {
    method include (line 218) | pub fn include(&self, include_paths: &VecDeque<PathBuf>) -> DirectiveR...
    method span (line 234) | pub fn span(&self) -> SourceSpan {
    method fmt (line 247) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 242) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 252) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type IncludeLib (line 273) | pub struct IncludeLib {
    method include_lib (line 283) | pub fn include_lib(&self, include_paths: &VecDeque<PathBuf>, code_path...
    method span (line 327) | pub fn span(&self) -> SourceSpan {
    method fmt (line 340) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 335) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 345) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Error (line 367) | pub struct Error {
    method span (line 376) | pub fn span(&self) -> SourceSpan {
    method fmt (line 389) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 384) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 394) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Warning (line 416) | pub struct Warning {
    method span (line 425) | pub fn span(&self) -> SourceSpan {
    method fmt (line 438) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 433) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 443) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Endif (line 464) | pub struct Endif {
    method span (line 470) | pub fn span(&self) -> SourceSpan {
    method fmt (line 483) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 478) | fn eq(&self, _other: &Self) -> bool {
  method read_from (line 488) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Else (line 506) | pub struct Else {
    method span (line 512) | pub fn span(&self) -> SourceSpan {
    method fmt (line 525) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 520) | fn eq(&self, _other: &Self) -> bool {
  method read_from (line 530) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Undef (line 548) | pub struct Undef {
    method span (line 557) | pub fn span(&self) -> SourceSpan {
    method name (line 562) | pub fn name(&self) -> Symbol {
    method fmt (line 573) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 568) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 578) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type If (line 599) | pub struct If {
    method span (line 608) | pub fn span(&self) -> SourceSpan {
    method fmt (line 621) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 616) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 626) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Elif (line 647) | pub struct Elif {
    method span (line 656) | pub fn span(&self) -> SourceSpan {
    method fmt (line 669) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 664) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 674) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  function read_condition (line 689) | fn read_condition<R, S>(reader: &mut R) -> Result<VecDeque<Lexed>>
  type Ifdef (line 728) | pub struct Ifdef {
    method span (line 737) | pub fn span(&self) -> SourceSpan {
    method name (line 742) | pub fn name(&self) -> Symbol {
    method fmt (line 753) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 748) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 758) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Ifndef (line 779) | pub struct Ifndef {
    method span (line 788) | pub fn span(&self) -> SourceSpan {
    method name (line 793) | pub fn name(&self) -> Symbol {
    method fmt (line 804) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 799) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 809) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Define (line 830) | pub struct Define {
    method span (line 842) | pub fn span(&self) -> SourceSpan {
    method fmt (line 857) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 850) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 873) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type File (line 922) | pub struct File {
    method span (line 933) | pub fn span(&self) -> SourceSpan {
    method fmt (line 946) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 941) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 951) | fn read_from<R, S>(reader: &mut R) -> Result<Self>

FILE: libeir_syntax_erl/src/preprocessor/errors.rs
  type PreprocessorError (line 20) | pub enum PreprocessorError {
    method to_diagnostic (line 112) | pub fn to_diagnostic(&self) -> Diagnostic {
    method from (line 278) | fn from(source: LexicalError) -> PreprocessorError {
    method from (line 283) | fn from(source: SourceError) -> PreprocessorError {
    method from (line 288) | fn from(err: TokenConvertError) -> PreprocessorError {
    method from (line 298) | fn from(diagnostic: Diagnostic) -> Self {
    method from (line 304) | fn from(source: crate::evaluator::EvalError) -> Self {

FILE: libeir_syntax_erl/src/preprocessor/macros.rs
  type MacroIdent (line 14) | pub enum MacroIdent {
    method ident (line 19) | pub fn ident(&self) -> Symbol {
    method arity (line 26) | pub fn arity(&self) -> Option<usize> {
    method from (line 35) | fn from(call: &MacroCall) -> MacroIdent {
    method from (line 50) | fn from(def: &super::directives::Define) -> MacroIdent {
  type MacroContainer (line 65) | pub struct MacroContainer {
    method new (line 70) | pub fn new() -> Self {
    method insert (line 77) | pub fn insert<T>(&mut self, key: T, def: MacroDef) -> bool
    method get (line 94) | pub fn get<'a, T>(&'a self, key: T) -> Option<&'a MacroDef>
    method undef (line 107) | pub fn undef(&mut self, symbol: &Symbol) -> bool {
    method defined (line 114) | pub fn defined(&self, symbol: &Symbol) -> bool {
    method defined_const (line 117) | pub fn defined_const(&self, symbol: &Symbol) -> bool {
    method defined_func (line 120) | pub fn defined_func(&self, symbol: &Symbol) -> bool {
  type MacroDef (line 127) | pub enum MacroDef {
    method has_variables (line 136) | pub fn has_variables(&self) -> bool {
  type MacroCall (line 149) | pub struct MacroCall {
    method span (line 155) | pub fn span(&self) -> SourceSpan {
    method name (line 165) | pub fn name(&self) -> Symbol {
    method fmt (line 170) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method read_from (line 180) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type NoArgsMacroCall (line 193) | pub struct NoArgsMacroCall {
    method span (line 198) | pub fn span(&self) -> SourceSpan {
  method read_from (line 203) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Stringify (line 215) | pub struct Stringify {
    method span (line 220) | pub fn span(&self) -> SourceSpan {
    method fmt (line 227) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method read_from (line 232) | fn read_from<R, S>(reader: &mut R) -> Result<Self>

FILE: libeir_syntax_erl/src/preprocessor/mod.rs
  type Preprocessed (line 22) | pub type Preprocessed = std::result::Result<(SourceIndex, Token, SourceI...
  type Result (line 24) | type Result<T> = std::result::Result<T, PreprocessorError>;

FILE: libeir_syntax_erl/src/preprocessor/preprocessor.rs
  type Errors (line 22) | type Errors<'a> = ErrorReceiverTee<'a, PreprocessorError, PreprocessorEr...
  type Preprocessor (line 36) | pub struct Preprocessor<'a, Reader: TokenReader> {
  function new (line 55) | pub fn new(parser: &Parser, tokens: Lexer<S>, errors: Errors<'a>) -> Self {
  function clone_with (line 94) | fn clone_with(&self, tokens: VecDeque<Lexed>) -> Preprocessor<TokenBuffe...
  function ignore (line 114) | fn ignore(&self) -> bool {
  function next_token (line 118) | fn next_token(&mut self) -> Result<Option<LexicalToken>, ()> {
  function expand_macro (line 166) | fn expand_macro(&self, call: MacroCall) -> PResult<VecDeque<LexicalToken...
  function try_expand_predefined_macro (line 174) | fn try_expand_predefined_macro(&self, call: &MacroCall) -> PResult<Optio...
  function expand_userdefined_macro (line 206) | fn expand_userdefined_macro(&self, call: MacroCall) -> PResult<VecDeque<...
  function expand_replacement (line 275) | fn expand_replacement(
  function try_read_directive (line 323) | fn try_read_directive(&mut self) -> Result<Option<Directive>, ()> {
  function eval_conditional (line 460) | fn eval_conditional(
  type Item (line 507) | type Item = Preprocessed;
  method next (line 509) | fn next(&mut self) -> Option<Self::Item> {
  type Branch (line 519) | struct Branch {
    method new (line 524) | pub fn new(entered: bool) -> Self {
    method switch_to_else_branch (line 530) | pub fn switch_to_else_branch(&mut self) -> Result<(), ()> {

FILE: libeir_syntax_erl/src/preprocessor/token_reader.rs
  type TokenReader (line 21) | pub trait TokenReader: Sized {
    method new (line 24) | fn new(codemap: Arc<CodeMap>, tokens: Self::Source) -> Self;
    method inject_include (line 26) | fn inject_include<P>(&mut self, path: P, directive: SourceSpan) -> Res...
    method read (line 30) | fn read<V: ReadFrom>(&mut self) -> Result<V> {
    method try_read (line 34) | fn try_read<V: ReadFrom>(&mut self) -> Result<Option<V>> {
    method try_read_macro_call (line 38) | fn try_read_macro_call(&mut self, macros: &MacroContainer) -> Result<O...
    method read_expected (line 84) | fn read_expected<V>(&mut self, expected: &V::Value) -> Result<V>
    method try_read_expected (line 91) | fn try_read_expected<V>(&mut self, expected: &V::Value) -> Result<Opti...
    method try_read_token (line 98) | fn try_read_token(&mut self) -> Result<Option<LexicalToken>>;
    method read_token (line 100) | fn read_token(&mut self) -> Result<LexicalToken>;
    method unread_token (line 102) | fn unread_token(&mut self, token: LexicalToken);
    type Source (line 112) | type Source = VecDeque<Lexed>;
    method new (line 114) | fn new(codemap: Arc<CodeMap>, tokens: Self::Source) -> Self {
    method inject_include (line 123) | fn inject_include<P>(&mut self, path: P, directive: SourceSpan) -> Res...
    method try_read_token (line 143) | fn try_read_token(&mut self) -> Result<Option<LexicalToken>> {
    method read_token (line 150) | fn read_token(&mut self) -> Result<LexicalToken> {
    method unread_token (line 158) | fn unread_token(&mut self, token: LexicalToken) {
    type Source (line 173) | type Source = Lexer<S>;
    method new (line 175) | fn new(codemap: Arc<CodeMap>, tokens: Self::Source) -> Self {
    method inject_include (line 184) | fn inject_include<P>(&mut self, path: P, directive: SourceSpan) -> Res...
    method try_read_token (line 202) | fn try_read_token(&mut self) -> Result<Option<LexicalToken>> {
    method read_token (line 209) | fn read_token(&mut self) -> Result<LexicalToken> {
    method unread_token (line 217) | fn unread_token(&mut self, token: LexicalToken) {
  type TokenBufferReader (line 106) | pub struct TokenBufferReader {
  type TokenStreamReader (line 164) | pub struct TokenStreamReader<S> {
  type ReadFrom (line 222) | pub trait ReadFrom: Sized {
    method read_from (line 223) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
    method try_read_from (line 231) | fn try_read_from<R, S>(reader: &mut R) -> Result<Option<Self>>
    method read_expected (line 251) | fn read_expected<R, S>(reader: &mut R, expected: &Self::Value) -> Resu...
    method try_read_expected (line 284) | fn try_read_expected<R, S>(reader: &mut R, expected: &Self::Value) -> ...
    method read_from (line 307) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type Expect (line 316) | pub trait Expect {
    method expect (line 319) | fn expect(&self, expected: &Self::Value) -> bool;
    type Value (line 323) | type Value = Symbol;
    method expect (line 325) | fn expect(&self, expected: &Self::Value) -> bool {
    type Value (line 331) | type Value = Token;
    method expect (line 333) | fn expect(&self, expected: &Self::Value) -> bool {

FILE: libeir_syntax_erl/src/preprocessor/token_stream.rs
  type TokenStream (line 6) | pub struct TokenStream<S> {
  function new (line 15) | pub fn new(current: Lexer<S>) -> Self {
  function include (line 23) | pub fn include(&mut self, next: Lexer<S>) {
  type Item (line 35) | type Item = Lexed;
  method next (line 37) | fn next(&mut self) -> Option<Self::Item> {

FILE: libeir_syntax_erl/src/preprocessor/types.rs
  type MacroName (line 15) | pub enum MacroName {
    method value (line 21) | pub fn value(&self) -> Token {
    method symbol (line 29) | pub fn symbol(&self) -> Symbol {
    method span (line 36) | pub fn span(&self) -> SourceSpan {
    method fmt (line 55) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 45) | fn eq(&self, other: &Self) -> bool {
  method hash (line 50) | fn hash<H: Hasher>(&self, hasher: &mut H) {
  method read_from (line 60) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type MacroVariables (line 74) | pub struct MacroVariables {
    method iter (line 81) | pub fn iter(&self) -> ListIter<IdentToken> {
    method len (line 86) | pub fn len(&self) -> usize {
    method is_empty (line 91) | pub fn is_empty(&self) -> bool {
    method span (line 95) | pub fn span(&self) -> SourceSpan {
    method fmt (line 106) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 101) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 111) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type MacroArgs (line 125) | pub struct MacroArgs {
    method iter (line 132) | pub fn iter(&self) -> ListIter<MacroArg> {
    method len (line 137) | pub fn len(&self) -> usize {
    method is_empty (line 142) | pub fn is_empty(&self) -> bool {
    method span (line 146) | pub fn span(&self) -> SourceSpan {
    method fmt (line 157) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 152) | fn eq(&self, other: &Self) -> bool {
  method read_from (line 162) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type MacroArg (line 176) | pub struct MacroArg {
    method span (line 183) | pub fn span(&self) -> SourceSpan {
    method fmt (line 190) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method try_read_from (line 198) | fn try_read_from<R, S>(reader: &mut R) -> Result<Option<Self>>
  type Tail (line 257) | pub enum Tail<T> {
  method eq (line 267) | fn eq(&self, other: &Self) -> bool {
  function fmt (line 283) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method read_from (line 293) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type List (line 310) | pub enum List<T> {
  function iter (line 316) | pub fn iter(&self) -> ListIter<T> {
  method eq (line 322) | fn eq(&self, other: &Self) -> bool {
  function fmt (line 333) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method read_from (line 341) | fn read_from<R, S>(reader: &mut R) -> Result<Self>
  type ListIter (line 356) | pub struct ListIter<'a, T: 'a>(ListIterInner<'a, T>);
  type Item (line 358) | type Item = &'a T;
  method next (line 359) | fn next(&mut self) -> Option<Self::Item> {
  type ListIterInner (line 365) | enum ListIterInner<'a, T: 'a> {
  type Item (line 371) | type Item = &'a T;
  method next (line 372) | fn next(&mut self) -> Option<Self::Item> {

FILE: libeir_syntax_erl/src/util/binary/static.rs
  type StaticBinaryElementError (line 20) | pub enum StaticBinaryElementError {
  function map_endian (line 36) | fn map_endian(endianness: Endianness) -> Endian {
  function append_number (line 44) | fn append_number(
  function append_static_binary_element (line 158) | pub fn append_static_binary_element(
  function simple_integer (line 238) | fn simple_integer() {
  function simple_integer_with_size (line 254) | fn simple_integer_with_size() {
  function simple_integer_little_endian_with_size (line 271) | fn simple_integer_little_endian_with_size() {

FILE: libeir_syntax_erl/src/util/encoding.rs
  type StringError (line 9) | pub enum StringError {
  method to_diagnostic (line 19) | fn to_diagnostic(&self) -> Diagnostic {
  type Encoding (line 35) | pub enum Encoding {
    method encode (line 56) | pub fn encode(&self, cp: u64, span: SourceSpan) -> Result<Encoded, Str...
  method fmt (line 45) | fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
  type Endianness (line 67) | pub enum Endianness {
    type Error (line 74) | type Error = ();
    method try_from (line 75) | fn try_from(end: EirEndianness) -> Result<Endianness, ()> {
  type Encoded (line 85) | pub enum Encoded {
    method swap (line 92) | pub fn swap(self) -> Self {
    method write (line 101) | pub fn write(self, endianness: Endianness, out: &mut Vec<u8>) {
    method write_le (line 108) | pub fn write_le(self, out: &mut Vec<u8>) {
    method write_be (line 129) | pub fn write_be(self, out: &mut Vec<u8>) {
    type T (line 151) | type T = u8;
    method bit_len (line 152) | fn bit_len(&self) -> usize {
    method read_word (line 162) | fn read_word(&self, n: usize) -> u8 {
  function encode_utf8 (line 179) | pub fn encode_utf8(cp: u64, span: SourceSpan) -> Result<Encoded, StringE...
  function encode_utf16 (line 205) | pub fn encode_utf16(cp: u64, span: SourceSpan) -> Result<Encoded, String...
  function encode_utf32 (line 231) | pub fn encode_utf32(cp: u64, span: SourceSpan) -> Result<Encoded, String...
  function encode_latin1 (line 248) | fn encode_latin1(cp: u64, _span: SourceSpan) -> Result<Encoded, StringEr...

FILE: libeir_syntax_erl/src/util/escape_stm.rs
  type EscapeStmError (line 5) | pub enum EscapeStmError<D> {
  function range (line 32) | pub fn range(&self) -> &(D, D) {
  function span (line 44) | pub fn span(&self) -> SourceSpan {
  method to_diagnostic (line 51) | fn to_diagnostic(&self) -> Diagnostic {
  type EscapeStm (line 65) | pub struct EscapeStm<D> {
  type EscapeStmState (line 72) | pub enum EscapeStmState {
  type EscapeStmAction (line 83) | pub enum EscapeStmAction {
  type EscapeStmOut (line 89) | pub struct EscapeStmOut<D> {
  function new (line 95) | pub fn new() -> Self {
  function reset (line 103) | pub fn reset(&mut self) {
  function is_norm (line 109) | pub fn is_norm(&self) -> bool {
  function transition (line 113) | pub fn transition(

FILE: libeir_syntax_erl/src/util/string.rs
  function string_to_codepoints (line 7) | pub fn string_to_codepoints(string: Ident) -> Result<Vec<u64>, StringTok...
  function string_to_binary (line 11) | pub fn string_to_binary(
  function string_literal_parse (line 34) | fn string_literal_parse() {
  function test_string_to_binary (line 76) | fn test_string_to_binary() {

FILE: libeir_syntax_erl/src/util/string_tokenizer.rs
  type StringTokenizeError (line 9) | pub enum StringTokenizeError {
  method to_diagnostic (line 16) | fn to_diagnostic(&self) -> Diagnostic {
  type StringTokenizer (line 24) | pub struct StringTokenizer {
    method new (line 34) | pub fn new(string: Ident) -> Self {
  type Item (line 47) | type Item = Result<(u64, SourceSpan), StringTokenizeError>;
  method next (line 48) | fn next(&mut self) -> Option<Self::Item> {
  function tokenize_plaintext (line 111) | fn tokenize_plaintext() {
  function tokenize_unicode_codepoint (line 120) | fn tokenize_unicode_codepoint() {

FILE: libeir_tests/src/control_flow/accumulate_list.rs
  function test_list_acc (line 13) | fn test_list_acc() {

FILE: libeir_tests/src/control_flow/fib.rs
  function test_fib (line 11) | fn test_fib() {

FILE: libeir_tests/src/control_flow/get_values.rs
  function get_values (line 22) | fn get_values() {

FILE: libeir_tests/src/control_flow/nth_root.rs
  function test_nth_root (line 13) | fn test_nth_root() {

FILE: libeir_tests/src/control_flow/shadowing.rs
  function pattern_variable_shadowing (line 11) | fn pattern_variable_shadowing() {
  function pattern_variable_shadowing_a (line 54) | fn pattern_variable_shadowing_a() {

FILE: libeir_tests/src/ct_runner.rs
  type SuiteSpec (line 9) | struct SuiteSpec {
  type SuiteEntrySpec (line 14) | enum SuiteEntrySpec {
  function get_suite_spec (line 19) | fn get_suite_spec(vm: &mut VMState, module: Ident) -> SuiteSpec {
  function run_ct_suite (line 81) | pub fn run_ct_suite(vm: &mut VMState, module: Ident) {

FILE: libeir_tests/src/errors.rs
  function test_basic_catch (line 11) | fn test_basic_catch() {
  function test_basic_catch_miss (line 52) | fn test_basic_catch_miss() {

FILE: libeir_tests/src/lib.rs
  function lower_file (line 23) | fn lower_file<S>(path: S, config: ParseConfig) -> Result<Module, ()>
  function lower (line 41) | pub fn lower<S>(input: S, config: ParseConfig) -> Result<Module, ()>
  function write_dot (line 59) | pub fn write_dot(module: &Module, ident: Option<FunctionIdent>) {
  function rand_error (line 73) | fn rand_error() {

FILE: libeir_tests/src/list_comprehensions.rs
  function test_list_comprehension_single_filter (line 13) | fn test_list_comprehension_single_filter() {
  function test_list_comprehension_single_list_generator (line 67) | fn test_list_comprehension_single_list_generator() {
  function test_list_comprehension_combinations (line 145) | fn test_list_comprehension_combinations() {
  function test_basic_comprehension (line 221) | fn test_basic_comprehension() {
  function test_list_comprehension_permutations (line 260) | fn test_list_comprehension_permutations() {
  function test_binary_comprehension (line 336) | fn test_binary_comprehension() {

FILE: libeir_tests/src/otp/mod.rs
  function compiler (line 15) | fn compiler() {
  function beam_disasm (line 40) | fn beam_disasm() {
  function core_parse (line 65) | fn core_parse() {
  function maps (line 90) | fn maps() {
  function match_suite (line 107) | fn match_suite() {
  function bs_match_suite (line 142) | fn bs_match_suite() {
  function maps_suite (line 167) | fn maps_suite() {
  function xmerl_scan (line 199) | fn xmerl_scan() {
  function xmerl_sax_parser_utf8 (line 224) | fn xmerl_sax_parser_utf8() {
  function foo (line 250) | fn foo() {
  function aa (line 268) | fn aa() {
  function unary_op_1 (line 301) | fn unary_op_1() {
  function unary_op_1_a (line 375) | fn unary_op_1_a() {

FILE: libeir_tests/src/patterns.rs
  function test_pattern_equality (line 13) | fn test_pattern_equality() {
  function test_tuple_pattern (line 45) | fn test_tuple_pattern() {
  function test_list_pattern (line 111) | fn test_list_pattern() {
  function test_fun_atom_pattern (line 160) | fn test_fun_atom_pattern() {
  function test_case_atom_pattern (line 211) | fn test_case_atom_pattern() {

FILE: libeir_tests/src/records.rs
  function record_creation (line 11) | fn record_creation() {
  function record_creation_a (line 139) | fn record_creation_a() {

FILE: tools/src/compile.rs
  method to_filter (line 66) | pub fn to_filter(self) -> log::LevelFilter {
  function make_erlang_frontend (line 77) | fn make_erlang_frontend(codemap: Arc<CodeMap>, matches: &ArgMatches) -> ...
  function make_frontend (line 96) | fn make_frontend(codemap: Arc<CodeMap>, matches: &ArgMatches) -> AnyFron...
  function setup_logger (line 104) | fn setup_logger(level: log::LevelFilter) {
  function main (line 120) | fn main() {

FILE: util/any_map/src/any_any_map.rs
  type AnyKey (line 6) | pub trait AnyKey: Clone + Hash + Eq + 'static {
  type AnyValueTrait (line 10) | trait AnyValueTrait {
    method clone (line 11) | fn clone(&self) -> Box<dyn AnyValueTrait>;
    method clone (line 17) | fn clone(&self) -> Box<dyn AnyValueTrait> {
  type AnyAnyMap (line 22) | pub struct AnyAnyMap<S = DefaultBuildHasher, A = Global>
    method new (line 42) | pub fn new() -> Self {
  method default (line 34) | fn default() -> Self {
  function insert (line 52) | pub fn insert<K: AnyKey>(&mut self, k: K, v: K::Value) -> Option<K::Value>
  function get (line 60) | pub fn get<K: AnyKey>(&self, k: &K) -> Option<&K::Value> {
  function get_mut (line 64) | pub fn get_mut<K: AnyKey>(&mut self, k: &K) -> Option<&mut K::Value> {

FILE: util/any_map/src/any_map.rs
  type DefaultBuildHasher (line 8) | pub type DefaultBuildHasher = FnvBuildHasher;
  type AnyKeyTrait (line 10) | trait AnyKeyTrait: 'static {
    method clone (line 11) | fn clone(&self) -> Box<dyn AnyKeyTrait>;
    method type_id (line 12) | fn type_id(&self) -> TypeId;
    method clone (line 18) | fn clone(&self) -> Box<dyn AnyKeyTrait> {
    method type_id (line 21) | fn type_id(&self) -> TypeId {
  function is (line 26) | fn is<T: Any>(&self) -> bool {
  function downcast_ref (line 31) | fn downcast_ref<'a, T: Any>(&'a self) -> Option<&'a T> {
  function make_hash (line 40) | fn make_hash<K: Hash + ?Sized>(hash_builder: &impl BuildHasher, val: &K)...
  function make_eq (line 46) | fn make_eq<Q, V>(k: &Q) -> impl Fn(&(AnyKey, V)) -> bool + '_
  type AnyKey (line 53) | struct AnyKey {
    method new (line 67) | pub fn new<K, S>(k: K, hb: &S) -> Self
    method eq_k (line 78) | pub fn eq_k<K>(&self, k: &K) -> bool
  method clone (line 58) | fn clone(&self) -> Self {
  type AnyMap (line 90) | pub struct AnyMap<V, S = DefaultBuildHasher, A = Global>
  method default (line 103) | fn default() -> Self {
  function get_hash (line 111) | fn get_hash<V>(data: &(AnyKey, V)) -> u64 {
  function new (line 116) | pub fn new() -> Self {
  function insert (line 126) | pub fn insert<K>(&mut self, k: K, v: V) -> Option<V>
  function get (line 140) | pub fn get<K>(&self, k: &K) -> Option<&V>
  function get_mut (line 151) | pub fn get_mut<K>(&mut self, k: &K) -> Option<&mut V>
  function simple_usage (line 168) | fn simple_usage() {

FILE: util/libeir_etf/src/constants.rs
  constant ATOM_CACHE_REF (line 3) | pub const ATOM_CACHE_REF: u8 = 82;
  constant SMALL_INTEGER_EXT (line 5) | pub const SMALL_INTEGER_EXT: u8 = 97;
  constant INTEGER_EXT (line 7) | pub const INTEGER_EXT: u8 = 98;
  constant FLOAT_EXT (line 10) | pub const FLOAT_EXT: u8 = 99;
  constant PORT_EXT (line 12) | pub const PORT_EXT: u8 = 102;
  constant NEW_PORT_EXT (line 14) | pub const NEW_PORT_EXT: u8 = 89;
  constant PID_EXT (line 16) | pub const PID_EXT: u8 = 103;
  constant NEW_PID_EXT (line 18) | pub const NEW_PID_EXT: u8 = 88;
  constant SMALL_TUPLE_EXT (line 20) | pub const SMALL_TUPLE_EXT: u8 = 104;
  constant LARGE_TUPLE_EXT (line 22) | pub const LARGE_TUPLE_EXT: u8 = 105;
  constant MAP_EXT (line 25) | pub const MAP_EXT: u8 = 116;
  constant NIL_EXT (line 27) | pub const NIL_EXT: u8 = 106;
  constant STRING_EXT (line 29) | pub const STRING_EXT: u8 = 107;
  constant LIST_EXT (line 31) | pub const LIST_EXT: u8 = 108;
  constant BINARY_EXT (line 33) | pub const BINARY_EXT: u8 = 109;
  constant SMALL_BIG_EXT (line 37) | pub const SMALL_BIG_EXT: u8 = 110;
  constant LARGE_BIG_EXT (line 40) | pub const LARGE_BIG_EXT: u8 = 111;
  constant NEWER_REFERENCE_EXT (line 42) | pub const NEWER_REFERENCE_EXT: u8 = 90;
  constant FUN_EXT (line 45) | pub const FUN_EXT: u8 = 117;
  constant NEW_FUN_EXT (line 49) | pub const NEW_FUN_EXT: u8 = 112;
  constant EXPORT_EXT (line 51) | pub const EXPORT_EXT: u8 = 113;
  constant BIT_BINARY_EXT (line 53) | pub const BIT_BINARY_EXT: u8 = 77;
  constant NEW_FLOAT_EXT (line 55) | pub const NEW_FLOAT_EXT: u8 = 70;
  constant ATOM_EXT (line 58) | pub const ATOM_EXT: u8 = 100;
  constant SMALL_ATOM_EXT (line 61) | pub const SMALL_ATOM_EXT: u8 = 115;
  constant ATOM_UTF8_EXT (line 63) | pub const ATOM_UTF8_EXT: u8 = 118;
  constant SMALL_ATOM_UTF8_EXT (line 65) | pub const SMALL_ATOM_UTF8_EXT: u8 = 119;

FILE: util/libeir_etf/src/decoder.rs
  type DecodeError (line 7) | pub enum DecodeError {
  type Decoder (line 15) | pub trait Decoder: Sized {
    method decode (line 16) | fn decode<S: Read>(reader: &mut Reader<S>) -> Result<Self, DecodeError>;

FILE: util/libeir_etf/src/encoder.rs
  type Encoder (line 7) | pub trait Encoder {
    method encode (line 8) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()>;
    method encode (line 12) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 18) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 24) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 32) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 116) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 131) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 147) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 152) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 157) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 162) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 167) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 172) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 181) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 186) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 195) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 204) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 213) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
    method encode (line 224) | fn encode<S: Write>(&self, writer: &mut Writer<S>) -> Result<()> {
  type A (line 30) | pub struct A<'a>(pub &'a str);
  type List (line 222) | pub struct List<H: IntoIterator<Item = I> + Copy, I: Encoder, T: Encoder...

FILE: util/libeir_etf/src/reader.rs
  type Reader (line 7) | pub struct Reader<S> {
  function new (line 12) | pub fn new(source: S) -> Self {
  type RawTag (line 17) | pub enum RawTag {
  function header (line 92) | pub fn header(&mut self) -> Result<()> {
  function raw_tag (line 100) | pub fn raw_tag(&mut self) -> Result<RawTag> {
  function term (line 252) | pub fn term(&mut self) -> Result<Term> {
  function read_atom_term_latin1 (line 299) | fn read_atom_term_latin1(&mut self, len: usize) -> Result<Term> {
  function read_atom_term_utf8 (line 313) | fn read_atom_term_utf8(&mut self, len: usize) -> Result<Term> {

FILE: util/libeir_etf/src/term.rs
  type TermTypes (line 3) | trait TermTypes {
  type Term (line 8) | pub enum Term {

FILE: util/libeir_etf/src/test/mod.rs
  function int_tuple (line 12) | fn int_tuple() {
  function test_1 (line 25) | fn test_1() {
  function test_2 (line 46) | fn test_2() {

FILE: util/libeir_etf/src/writer.rs
  type Writer (line 9) | pub struct Writer<S> {
  type WriterState (line 15) | enum WriterState {
    method decr (line 22) | fn decr(&mut self) {
  function new (line 33) | pub fn new(sink: S) -> Self {
  function pop (line 40) | pub fn pop(&mut self) {
  function next_kv (line 47) | pub fn next_kv(&mut self) {
  function next_tail (line 58) | pub fn next_tail(&mut self) {
  function push_data (line 68) | pub fn push_data(&mut self, data: &[u8]) -> Result<()> {
  function raw_small_integer_ext (line 86) | pub fn raw_small_integer_ext(&mut self, int: u8) -> Result<()> {
  function raw_integer_ext (line 92) | pub fn raw_integer_ext(&mut self, int: i32) -> Result<()> {
  function raw_big_ext (line 98) | pub fn raw_big_ext(&mut self, int: &BigInt) -> Result<()> {
  function raw_new_float_ext (line 121) | pub fn raw_new_float_ext(&mut self, float: f32) -> Result<()> {
  function raw_nil (line 127) | pub fn raw_nil(&mut self) -> Result<()> {
  function raw_atom_utf8_ext (line 132) | pub fn raw_atom_utf8_ext(&mut self, data: &str) -> Result<()> {
  function raw_small_atom_utf8_ext (line 142) | pub fn raw_small_atom_utf8_ext(&mut self, data: &str) -> Result<()> {
  function raw_small_tuple_ext (line 152) | pub fn raw_small_tuple_ext(&mut self, arity: u8) -> Result<()> {
  function raw_large_tuple_ext (line 160) | pub fn raw_large_tuple_ext(&mut self, arity: u16) -> Result<()> {
  function raw_map_ext (line 168) | pub fn raw_map_ext(&mut self, size: u32) -> Result<()> {
  function raw_list_ext (line 176) | pub fn raw_list_ext(&mut self, length: u32) -> Result<()> {
  function raw_binary_ext (line 184) | pub fn raw_binary_ext(&mut self, length: u32) -> Result<()> {
  function raw_bit_binary_ext (line 192) | pub fn raw_bit_binary_ext(&mut self, length: u32, last_bits: u8) -> Resu...
  function integer_u8 (line 206) | pub fn integer_u8(&mut self, int: u8) -> Result<()> {
  function integer_i32 (line 209) | pub fn integer_i32(&mut self, int: i32) -> Result<()> {
  function integer_big (line 212) | pub fn integer_big(&mut self, int: &BigInt) -> Result<()> {
  function float (line 216) | pub fn float(&mut self, num: f32) -> Result<()> {
  function nil (line 219) | pub fn nil(&mut self) -> Result<()> {
  function atom (line 222) | pub fn atom(&mut self, string: &str) -> Result<()> {
  function tuple (line 232) | pub fn tuple(&mut self, len: usize) -> Result<()> {
  function map (line 241) | pub fn map<N: TryInto<u32>>(&mut self, len: N) -> Result<()> {
  function list (line 248) | pub fn list<N: TryInto<u32>>(&mut self, len: N) -> Result<()> {
  function binary (line 255) | pub fn binary<N: TryInto<u32>>(&mut self, len: N) -> Result<()> {
  function bit_binary (line 262) | pub fn bit_binary<N: TryInto<u32>>(&mut self, len: N, last_bits: u8) -> ...
  function term (line 272) | pub fn term(&mut self, term: &Term) -> Result<()> {

FILE: util/libeir_util_binary/src/bitvec.rs
  type BitVec (line 8) | pub struct BitVec {
    method new (line 14) | pub fn new() -> Self {
    method with_size (line 21) | pub fn with_size(size: usize) -> Self {
    method clear (line 29) | pub fn clear(&mut self) {
    method empty (line 34) | pub fn empty(&mut self) -> bool {
    method try_as_byte_aligned_slice (line 38) | pub fn try_as_byte_aligned_slice(&self) -> Option<&[u8]> {
    method len (line 46) | pub fn len(&self) -> usize {
    method as_ref (line 50) | pub fn as_ref(&self) -> &[u8] {
    method get (line 54) | pub fn get(&self, n: usize) -> Option<u8> {
    method push (line 58) | pub fn push<R>(&mut self, from: R)
    method pop (line 78) | pub fn pop<R>(&mut self, to: &mut R) -> Option<()>
    method iter_bytes (line 107) | pub fn iter_bytes(&self) -> BitVecBytesIterator {
    method from (line 123) | fn from(buf: Vec<u8>) -> BitVec {
    method eq (line 210) | fn eq(&self, other: &O) -> bool {
    method partial_cmp (line 222) | fn partial_cmp(&self, other: &O) -> Option<Ordering> {
  method default (line 117) | fn default() -> Self {
  type BitVecBytesIterator (line 131) | pub struct BitVecBytesIterator<'a> {
  type Item (line 137) | type Item = u8;
  method next (line 138) | fn next(&mut self) -> Option<u8> {
  type T (line 187) | type T = u8;
  method bit_len (line 188) | fn bit_len(&self) -> usize {
  method read_word (line 193) | fn read_word(&self, n: usize) -> u8 {
  method write_word (line 198) | fn write_word(&mut self, n: usize, data: u8, mask: u8) {
  method cmp (line 231) | fn cmp(&self, other: &Self) -> Ordering {
  method hash (line 237) | fn hash<H>(&self, state: &mut H)
  function basic_push_pop (line 253) | fn basic_push_pop() {

FILE: util/libeir_util_binary/src/extend.rs
  type ExtendWords (line 8) | pub struct ExtendWords<I: BitCarrier> {
  type T (line 19) | type T = I::T;
  method bit_len (line 20) | fn bit_len(&self) -> usize {
  method read_word (line 29) | fn read_word(&self, n: usize) -> I::T {
  type Extend (line 63) | pub type Extend<I> = BitSlice<ExtendWords<I>>;
  function extend_words_pad (line 65) | pub fn extend_words_pad<I: BitCarrier>(inner: I, extend: I::T, head_word...
  function extend_bits (line 74) | pub fn extend_bits<I: BitCarrier>(inner: I, extend: I::T, head_bits: usi...
  function extend_words_pad (line 89) | fn extend_words_pad() {

FILE: util/libeir_util_binary/src/impls.rs
  type T (line 78) | type T = u8;
  method bit_len (line 79) | fn bit_len(&self) -> usize {
  method read_word (line 84) | fn read_word(&self, _n: usize) -> u8 {
  method write_word (line 89) | fn write_word(&mut self, n: usize, data: u8, mask: u8) {
  type T (line 105) | type T = Tr;
  method bit_len (line 106) | fn bit_len(&self) -> usize {
  method read_word (line 114) | fn read_word(&self, n: usize) -> Self::T {
  type T (line 124) | type T = Tr;
  method bit_len (line 125) | fn bit_len(&self) -> usize {
  method read_word (line 133) | fn read_word(&self, n: usize) -> Self::T {
  method write_word (line 141) | fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {
  type T (line 161) | type T = Tr;
  method bit_len (line 162) | fn bit_len(&self) -> usize {
  method read_word (line 170) | fn read_word(&self, n: usize) -> Self::T {
  method write_word (line 178) | fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {
  type T (line 187) | type T = Tr;
  method bit_len (line 188) | fn bit_len(&self) -> usize {
  method read_word (line 196) | fn read_word(&self, n: usize) -> Self::T {
  type T (line 205) | type T = Tr;
  method bit_len (line 206) | fn bit_len(&self) -> usize {
  method read_word (line 214) | fn read_word(&self, n: usize) -> Self::T {
  method write_word (line 222) | fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {
  type T (line 231) | type T = Tr;
  method bit_len (line 232) | fn bit_len(&self) -> usize {
  method read_word (line 240) | fn read_word(&self, n: usize) -> Self::T {
  method write_word (line 248) | fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {

FILE: util/libeir_util_binary/src/integer.rs
  type Endian (line 8) | pub enum Endian {
  type T (line 22) | type T = u8;
  method bit_len (line 23) | fn bit_len(&self) -> usize {
  function integer_to_carrier (line 33) | pub fn integer_to_carrier(mut int: BigInt, bits: usize, endian: Endian) ...
  function carrier_to_buf (line 89) | fn carrier_to_buf<C>(carrier: C, signed: bool, endian: Endian) -> (Vec<u...
  function carrier_to_integer (line 132) | pub fn carrier_to_integer<C>(carrier: C, signed: bool, endian: Endian) -...
  function integer_adapter_basic (line 164) | fn integer_adapter_basic() {
  function integer_adapter_unaligned (line 185) | fn integer_adapter_unaligned() {
  function integer_adapter_negative (line 216) | fn integer_adapter_negative() {
  function integer_carrier_to_buf (line 237) | fn integer_carrier_to_buf() {
  function integer_round_trip_basic (line 317) | fn integer_round_trip_basic() {
  function integer_round_trip_unaligned (line 356) | fn integer_round_trip_unaligned() {

FILE: util/libeir_util_binary/src/lib.rs
  type BitTransport (line 26) | pub trait BitTransport:
    constant SIZE (line 39) | const SIZE: usize;
    constant BIT_SIZE (line 40) | const BIT_SIZE: usize = Self::SIZE * 8;
    constant ZERO (line 42) | const ZERO: Self;
    constant ONE (line 43) | const ONE: Self;
    constant MAX (line 44) | const MAX: Self;
    constant SIZE (line 48) | const SIZE: usize = 1;
    constant ZERO (line 49) | const ZERO: u8 = 0;
    constant ONE (line 50) | const ONE: u8 = 0;
    constant MAX (line 51) | const MAX: u8 = 0xff;
  type BitCarrier (line 56) | pub trait BitCarrier {
    method bit_len (line 60) | fn bit_len(&self) -> usize;
    method word_len (line 63) | fn word_len(&self) -> usize {
    method partial_bit_len (line 67) | fn partial_bit_len(&self) -> usize {
    method extend_words_pad (line 76) | fn extend_words_pad(self, extend: Self::T, head_words: usize, tail_wor...
    method slice_bits (line 83) | fn slice_bits(self, offset: usize, length: usize) -> BitSlice<Self>
    method extend_bits (line 90) | fn extend_bits(self, extend: Self::T, head_bits: usize, tail_bits: usi...
  type BitRead (line 98) | pub trait BitRead: BitCarrier {
    method read_word (line 102) | fn read_word(&self, n: usize) -> Self::T;
    method read_bit (line 104) | fn read_bit(&self, bit_n: usize) -> bool {
    method read (line 114) | fn read<P>(&self, to: &mut P)
    method iter_words (line 122) | fn iter_words(&self) -> CarrierWordIter<Self, Self::T>
  type BitWrite (line 135) | pub trait BitWrite: BitCarrier {
    method write_word (line 139) | fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T);
    method write (line 143) | fn write<P>(&mut self, from: P)
  function copy (line 163) | pub fn copy<S, D, T>(from: S, mut to: D)
  type CarrierWordIter (line 172) | pub struct CarrierWordIter<'a, I, T>
  type Item (line 187) | type Item = T;
  method next (line 188) | fn next(&mut self) -> Option<T> {

FILE: util/libeir_util_binary/src/slice.rs
  type BitSlice (line 10) | pub struct BitSlice<I> {
  type T (line 21) | type T = Tr;
  method bit_len (line 22) | fn bit_len(&self) -> usize {
  method read_word (line 30) | fn read_word(&self, n: usize) -> Self::T {
  method write_word (line 44) | fn write_word(&mut self, n: usize, data: Self::T, mask: Self::T) {
  function with_offset_length (line 70) | pub fn with_offset_length(inner: I, bit_offset: usize, bit_len: usize) -...
  function eq (line 102) | fn eq(&self, other: &O) -> bool {
  function partial_cmp (line 116) | fn partial_cmp(&self, other: &O) -> Option<Ordering> {
  method cmp (line 128) | fn cmp(&self, other: &Self) -> Ordering {
  method hash (line 137) | fn hash<H>(&self, state: &mut H)

FILE: util/libeir_util_datastructures/src/aux_hash_map.rs
  type AuxHashMap (line 49) | pub struct AuxHashMap<K, V, C, S = RandomState, A = Global>
  function new (line 60) | pub fn new() -> Self {
  function with_hasher (line 67) | pub fn with_hasher(hash_builder: S) -> Self {
  function iter (line 76) | pub fn iter(&self) -> Iter<'_, K, V> {
  function make_hash (line 87) | fn make_hash<C, K: AuxHash<C> + ?Sized>(
  function try_insert (line 103) | pub fn try_insert(&mut self, k: K, v: V, container: &C) -> Result<(), ()> {
  function get (line 119) | pub fn get<Q: ?Sized>(&self, k: &Q, container: &C) -> Option<&V>
  function get_key_value (line 128) | pub fn get_key_value<Q: ?Sized>(&self, k: &Q, container: &C) -> Option<(...
  method default (line 148) | fn default() -> Self {
  method fmt (line 159) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Iter (line 165) | pub struct Iter<'a, K, V> {
  type Item (line 170) | type Item = (&'a K, &'a V);
  method next (line 173) | fn next(&mut self) -> Option<(&'a K, &'a V)> {
  method size_hint (line 180) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: util/libeir_util_datastructures/src/aux_traits/bforest_impl.rs
  function aux_fmt (line 6) | fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {

FILE: util/libeir_util_datastructures/src/aux_traits/entity_impl.rs
  function aux_fmt (line 7) | fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {
  function aux_fmt (line 15) | fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {
  function aux_fmt (line 23) | fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {

FILE: util/libeir_util_datastructures/src/aux_traits/mod.rs
  type HasAux (line 8) | pub trait HasAux<Inner> {
    method get_aux (line 9) | fn get_aux(&self) -> &Inner;
  method get_aux (line 12) | fn get_aux(&self) -> &Self {
  function get_aux (line 17) | fn get_aux(&self) -> &T {
  type AuxDebug (line 22) | pub trait AuxDebug<Aux> {
    method aux_fmt (line 23) | fn aux_fmt(&self, f: &mut Formatter<'_>, container: &Aux) -> FmtResult;
  type AuxHash (line 27) | pub trait AuxHash<Aux> {
    method aux_hash (line 28) | fn aux_hash<H: Hasher>(&self, state: &mut H, container: &Aux);
  type AuxEq (line 32) | pub trait AuxEq<Aux> {
    method aux_eq (line 33) | fn aux_eq(&self, other: &Self, self_container: &Aux, other_container: ...
    method aux_ne (line 34) | fn aux_ne(&self, other: &Self, self_container: &Aux, other_container: ...
  type AuxImpl (line 39) | pub struct AuxImpl<'a, V, Aux>(pub &'a V, pub &'a Aux);
  method fmt (line 41) | fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
  method hash (line 46) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 51) | fn eq(&self, rhs: &Self) -> bool {

FILE: util/libeir_util_datastructures/src/aux_traits/std_impl/mod.rs
  function aux_fmt (line 7) | fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {
  function aux_hash (line 12) | fn aux_hash<H: Hasher>(&self, state: &mut H, aux: &Aux) {
  function aux_eq (line 17) | fn aux_eq(&self, other: &Self, self_aux: &Aux, other_aux: &Aux) -> bool {
  function aux_fmt (line 25) | fn aux_fmt(&self, f: &mut Formatter<'_>, aux: &C) -> FmtResult {

FILE: util/libeir_util_datastructures/src/dedup_aux_primary_map.rs
  type DedupPrimaryMap (line 8) | pub type DedupPrimaryMap<K, V> = DedupAuxPrimaryMap<K, V, ()>;
  type DedupAuxPrimaryMap (line 11) | pub struct DedupAuxPrimaryMap<K, V, C>
  function new (line 25) | pub fn new() -> Self {
  function push (line 32) | pub fn push(&mut self, v: V, c: &C) -> K
  type Output (line 51) | type Output = V;
  function index (line 52) | fn index(&self, key: K) -> &V {

FILE: util/libeir_util_datastructures/src/hashmap_stack.rs
  type HashMapStack (line 6) | pub struct HashMapStack<K, V> {
  function new (line 14) | pub fn new() -> Self {
  function push (line 18) | pub fn push(&mut self) {
  function pop (line 22) | pub fn pop(&mut self) {
  function layer (line 30) | pub fn layer(&self, n: usize) -> &HashMap<K, V> {
  function insert (line 34) | pub fn insert(&mut self, key: K, value: V) {
  function get (line 41) | pub fn get<'a>(&self, key: &K) -> Option<&V> {
  function contains_key (line 45) | pub fn contains_key(&self, key: &K) -> bool {
  function height (line 53) | pub fn height(&self) -> usize {
  function resolve_first (line 57) | pub fn resolve_first<'a, F, T>(&'a self, resolver: F) -> Option<T>
  function flatten (line 70) | pub fn flatten(&self) -> HashMap<&K, &V> {
  function flatten_clone (line 88) | pub fn flatten_clone(&self) -> HashMap<K, V> {
  type Output (line 105) | type Output = V;
  function index (line 107) | fn index(&self, index: &K) -> &V {
  method fmt (line 117) | fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
  function simple (line 128) | fn simple() {
  function insert_in_empty (line 155) | fn insert_in_empty() {
  function flatten (line 161) | fn flatten() {

FILE: util/libeir_util_datastructures/src/pooled_entity_set.rs
  type EntitySetPool (line 13) | pub struct EntitySetPool<E> {
  function new (line 18) | pub fn new() -> Self {
  type PooledSetValue (line 27) | struct PooledSetValue(u64);
  method reserved_value (line 30) | fn reserved_value() -> Self {
  method index (line 36) | fn index(self) -> usize {
  method new (line 39) | fn new(n: usize) -> Self {
  type EntitySet (line 46) | pub struct EntitySet<K>
  function aux_fmt (line 55) | fn aux_fmt(&self, f: &mut std::fmt::Formatter, aux: &C) -> std::fmt::Res...
  function aux_hash (line 62) | fn aux_hash<H: Hasher>(&self, hasher: &mut H, aux: &C) {
  function aux_eq (line 72) | fn aux_eq(&self, other: &Self, self_aux: &C, other_aux: &C) -> bool {
  method default (line 78) | fn default() -> Self {
  function new (line 90) | pub fn new() -> Self {
  function contains (line 97) | pub fn contains(&self, k: K, pool: &EntitySetPool<K>) -> bool {
  function size (line 111) | pub fn size(&self, pool: &EntitySetPool<K>) -> usize {
  function clear (line 120) | pub fn clear(&mut self, pool: &mut EntitySetPool<K>) {
  function grow_to_pages (line 126) | fn grow_to_pages(&mut self, pages: usize, pool: &mut EntitySetPool<K>) {
  function insert (line 136) | pub fn insert(&mut self, k: K, pool: &mut EntitySetPool<K>) -> bool {
  function remove (line 154) | pub fn remove(&mut self, k: K, pool: &mut EntitySetPool<K>) -> bool {
  function make_copy (line 171) | pub fn make_copy(&self, pool: &mut EntitySetPool<K>) -> EntitySet<K> {
  function union (line 186) | pub fn union(&mut self, other: &EntitySet<K>, pool: &mut EntitySetPool<K...
  function iter (line 199) | pub fn iter<'a>(&self, pool: &'a EntitySetPool<K>) -> EntitySetIter<'a, ...
  function eq (line 210) | pub fn eq(&self, other: &EntitySet<K>, pool: &EntitySetPool<K>) -> bool {
  function eq_other (line 214) | pub fn eq_other(
  function bind (line 256) | pub fn bind<'a>(&self, pool: &'a EntitySetPool<K>) -> BoundEntitySet<'a,...
  type BoundEntitySet (line 265) | pub struct BoundEntitySet<'a, K: EntityRef> {
  function contains (line 270) | pub fn contains(&self, k: K) -> bool {
  function size (line 274) | pub fn size(&self) -> usize {
  function iter (line 278) | pub fn iter(&self) -> EntitySetIter<'_, K> {
  type Item (line 283) | type Item = K;
  type IntoIter (line 284) | type IntoIter = EntitySetIter<'a, K>;
  method into_iter (line 285) | fn into_iter(self) -> EntitySetIter<'a, K> {
  method fmt (line 293) | fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
  method eq (line 298) | fn eq(&self, rhs: &BoundEntitySet<K>) -> bool {
  type EntitySetIter (line 304) | pub struct EntitySetIter<'a, T>
  type Item (line 319) | type Item = T;
  method next (line 321) | fn next(&mut self) -> Option<T> {
  type TestEntity (line 360) | pub struct TestEntity(u32);
  function test_pooled_set (line 364) | fn test_pooled_set() {
  function test_pooled_set_remove (line 423) | fn test_pooled_set_remove() {
  function test_pooled_set_eq (line 441) | fn test_pooled_set_eq() {
  function test_iterator (line 467) | fn test_iterator() {

FILE: util/libeir_util_dot_graph/src/lib.rs
  constant DOT_BREAK (line 9) | const DOT_BREAK: &str = "<br align=\"left\" />";
  function format_label (line 11) | fn format_label(label: &str, out: &mut String) {
  type NodeId (line 27) | pub trait NodeId {
    method make_id (line 28) | fn make_id(&self, out: &mut String);
    method make_id (line 31) | fn make_id(&self, out: &mut String) {
    method make_id (line 40) | fn make_id(&self, out: &mut String) {
    method make_id (line 49) | fn make_id(&self, out: &mut String) {
    method make_id (line 59) | fn make_id(&self, out: &mut String) {
  type DisplayNid (line 38) | pub struct DisplayNid<I: Display>(pub I);
  type PrefixedNid (line 47) | pub struct PrefixedNid<P: Display, I: NodeId>(pub P, pub I);
  type SubNid (line 57) | pub struct SubNid<I: NodeId, S: Display>(pub I, pub S);
  type ContentFormatting (line 65) | pub trait ContentFormatting {
    method make_raw (line 66) | fn make_raw(&self, out: &mut String);
    method make_raw (line 69) | fn make_raw(&self, out: &mut String) {
  type Content (line 74) | pub trait Content {
    method make_raw (line 75) | fn make_raw(&self, out: &mut String);
    method make_raw (line 78) | fn make_raw(&self, out: &mut String) {
  type StructuredNode (line 83) | pub struct StructuredNode {}
    method text (line 85) | pub fn text<F: ContentFormatting>(&mut self, _content: F) {}
    method vertical (line 86) | pub fn vertical(&mut self, _cells: &[()]) {}
    method horizontal (line 87) | pub fn horizontal(&mut self, _cells: &[()]) {}
  type GraphPrinter (line 90) | pub struct GraphPrinter<O: Write> {
  function new (line 97) | pub fn new() -> Self {
  function finish_run_dot (line 101) | pub fn finish_run_dot(self, out: &Path) {
  function with_out (line 138) | pub fn with_out(out: O) -> Self {
  function finish (line 156) | pub fn finish(mut self) -> Result<O, Error> {
  function node (line 166) | pub fn node<I>(&mut self, id: I, label: &str)
  function edge (line 189) | pub fn edge<I1, I2>(&mut self, from: I1, to: I2, label: &str)
  function w (line 220) | fn w<F>(&mut self, f: F)
  function basic (line 283) | fn basic() {
  function basic_to_file (line 292) | fn basic_to_file() {

FILE: util/libeir_util_dot_graph/src/tablegen.rs
  type Cell (line 5) | pub enum Cell<A: Alloc, T> {

FILE: util/libeir_util_number/src/bigint_to_float.rs
  function bigint_to_double (line 4) | pub fn bigint_to_double(big: &BigInt) -> f64 {
  function test_bigint_to_double (line 27) | fn test_bigint_to_double() {

FILE: util/libeir_util_number/src/binary.rs
  type T (line 5) | type T = u8;
  method bit_len (line 6) | fn bit_len(&self) -> usize {
  type IntegerBits (line 15) | pub enum IntegerBits {
  type T (line 22) | type T = u8;
  method bit_len (line 23) | fn bit_len(&self) -> usize {
  method read_word (line 32) | fn read_word(&self, n: usize) -> u8 {
  method encode_bitstring (line 43) | pub fn encode_bitstring(&self, bits: usize, endian: Endian) -> IntegerBi...
  function unsigned_big_endian_bigint (line 184) | fn unsigned_big_endian_bigint() {
  function unsigned_little_endian_bigint (line 196) | fn unsigned_little_endian_bigint() {
  function signed_big_endian_bigint (line 208) | fn signed_big_endian_bigint() {
  function signed_little_endian_bigint (line 220) | fn signed_little_endian_bigint() {
  function unsigned_big_endian_smallint (line 232) | fn unsigned_big_endian_smallint() {
  function unsigned_little_endian_smallint (line 244) | fn unsigned_little_endian_smallint() {
  function signed_big_endian_smallint (line 256) | fn signed_big_endian_smallint() {
  function signed_little_endian_smallint (line 268) | fn signed_little_endian_smallint() {
  function num_to_bitstring (line 280) | fn num_to_bitstring() {

FILE: util/libeir_util_number/src/float.rs
  type Float (line 13) | pub struct Float(f64);
    method new (line 16) | pub fn new(float: f64) -> Result<Float, FloatError> {
    method raw (line 22) | pub fn raw(&self) -> u64 {
    method inner (line 26) | pub fn inner(&self) -> f64 {
    method plus (line 30) | pub fn plus(&self) -> Float {
    method is_zero (line 38) | pub fn is_zero(&self) -> bool {
    method to_integer (line 42) | pub fn to_integer(&self) -> Integer {
    method is_precise (line 50) | pub fn is_precise(&self) -> bool {
    method fmt (line 129) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    type Output (line 135) | type Output = Result<Float, FloatError>;
    method add (line 136) | fn add(self, rhs: &Integer) -> Self::Output {
    type Output (line 148) | type Output = Result<Float, FloatError>;
    method sub (line 149) | fn sub(self, rhs: &Integer) -> Self::Output {
    type Output (line 161) | type Output = Result<Float, FloatError>;
    method mul (line 162) | fn mul(self, rhs: &Integer) -> Self::Output {
    type Output (line 174) | type Output = Result<Float, FloatError>;
    method div (line 175) | fn div(self, rhs: &Integer) -> Self::Output {
    type Output (line 187) | type Output = Result<Float, FloatError>;
    method rem (line 188) | fn rem(self, rhs: &Integer) -> Self::Output {
  type FloatError (line 56) | pub enum FloatError {
    method from_category (line 61) | pub fn from_category(category: FpCategory) -> Result<(), Self> {
    method fmt (line 71) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  method hash (line 92) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 98) | fn eq(&self, rhs: &Float) -> bool {
  method partial_cmp (line 105) | fn partial_cmp(&self, rhs: &Float) -> Option<Ordering> {
  method cmp (line 110) | fn cmp(&self, rhs: &Float) -> Ordering {
  type Output (line 122) | type Output = Float;
  method neg (line 123) | fn neg(self) -> Self::Output {
  type Output (line 141) | type Output = Result<Float, FloatError>;
  function add (line 142) | fn add(self, rhs: Float) -> Self::Output {
  type Output (line 154) | type Output = Result<Float, FloatError>;
  function sub (line 155) | fn sub(self, rhs: Float) -> Self::Output {
  type Output (line 167) | type Output = Result<Float, FloatError>;
  function mul (line 168) | fn mul(self, rhs: Float) -> Self::Output {
  type Output (line 180) | type Output = Result<Float, FloatError>;
  function div (line 181) | fn div(self, rhs: Float) -> Self::Output {
  type Output (line 193) | type Output = Result<Float, FloatError>;
  function rem (line 194) | fn rem(self, rhs: Float) -> Self::Output {

FILE: util/libeir_util_number/src/integer.rs
  type Integer (line 13) | pub enum Integer {
    method is_zero (line 19) | pub fn is_zero(&self) -> bool {
    method plus (line 26) | pub fn plus(&self) -> Integer {
    method to_float (line 34) | pub fn to_float(&self) -> f64 {
    method to_efloat (line 41) | pub fn to_efloat(&self) -> Result<Float, FloatError> {
    method to_bigint (line 45) | pub fn to_bigint(self) -> BigInt {
    method shrink (line 52) | pub fn shrink(self) -> Self {
    method from_string_radix (line 65) | pub fn from_string_radix(string: &str, radix: u32) -> Option<Integer> {
    method to_u64 (line 73) | pub fn to_u64(&self) -> Option<u64> {
    method to_usize (line 77) | pub fn to_usize(&self) -> Option<usize> {
    method eq (line 133) | fn eq(&self, rhs: &f64) -> bool {
    method partial_cmp (line 146) | fn partial_cmp(&self, rhs: &f64) -> Option<Ordering> {
    method eq (line 160) | fn eq(&self, rhs: &char) -> bool {
    method partial_cmp (line 173) | fn partial_cmp(&self, rhs: &char) -> Option<Ordering> {
    method eq (line 187) | fn eq(&self, rhs: &i64) -> bool {
    method partial_cmp (line 200) | fn partial_cmp(&self, rhs: &i64) -> Option<Ordering> {
    type Output (line 214) | type Output = Integer;
    method shr (line 215) | fn shr(self, num: u32) -> Integer {
    type Output (line 221) | type Output = Integer;
    method shl (line 222) | fn shl(self, num: u32) -> Integer {
    type Output (line 229) | type Output = Integer;
    method mul (line 230) | fn mul(self, rhs: i64) -> Integer {
    type Output (line 242) | type Output = Integer;
    method mul (line 243) | fn mul(self, rhs: &Integer) -> Integer {
    type Output (line 253) | type Output = Result<Integer, DivisionError>;
    method div (line 254) | fn div(self, rhs: &Integer) -> Self::Output {
    type Output (line 268) | type Output = Integer;
    method add (line 269) | fn add(self, rhs: &Integer) -> Integer {
    type Output (line 279) | type Output = Integer;
    method sub (line 280) | fn sub(self, rhs: &Integer) -> Integer {
    type Output (line 290) | type Output = Integer;
    method rem (line 291) | fn rem(self, rhs: &Integer) -> Integer {
    type Output (line 302) | type Output = Integer;
    method bitand (line 303) | fn bitand(self, rhs: &Integer) -> Integer {
    type Output (line 313) | type Output = Integer;
    method bitor (line 314) | fn bitor(self, rhs: &Integer) -> Integer {
    type Output (line 324) | type Output = Integer;
    method bitxor (line 325) | fn bitxor(self, rhs: &Integer) -> Integer {
    method from (line 383) | fn from(i: i64) -> Integer {
    method from (line 388) | fn from(i: u64) -> Integer {
    method from (line 393) | fn from(i: i32) -> Integer {
    method from (line 398) | fn from(i: usize) -> Integer {
    method from (line 403) | fn from(i: char) -> Integer {
    method from (line 408) | fn from(i: BigInt) -> Integer {
  method fmt (line 83) | fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
  type Err (line 92) | type Err = ParseBigIntError;
  method from_str (line 93) | fn from_str(s: &str) -> Result<Self, ParseBigIntError> {
  method eq (line 105) | fn eq(&self, rhs: &Integer) -> bool {
  method partial_cmp (line 117) | fn partial_cmp(&self, rhs: &Integer) -> Option<Ordering> {
  method cmp (line 127) | fn cmp(&self, rhs: &Integer) -> Ordering {
  function eq (line 141) | fn eq(&self, rhs: &Integer) -> bool {
  function partial_cmp (line 154) | fn partial_cmp(&self, rhs: &Integer) -> Option<Ordering> {
  function eq (line 168) | fn eq(&self, rhs: &Integer) -> bool {
  function partial_cmp (line 181) | fn partial_cmp(&self, rhs: &Integer) -> Option<Ordering> {
  function eq (line 195) | fn eq(&self, rhs: &Integer) -> bool {
  function partial_cmp (line 208) | fn partial_cmp(&self, rhs: &Integer) -> Option<Ordering> {
  type Output (line 336) | type Output = Integer;
  method neg (line 337) | fn neg(self) -> Integer {
  type Output (line 345) | type Output = Integer;
  method not (line 346) | fn not(self) -> Integer {
  method to_i64 (line 355) | fn to_i64(&self) -> Option<i64> {
  method to_u64 (line 361) | fn to_u64(&self) -> Option<u64> {
  method from_i64 (line 370) | fn from_i64(n: i64) -> Option<Integer> {
  method from_u64 (line 373) | fn from_u64(n: u64) -> Option<Integer> {

FILE: util/libeir_util_number/src/lib.rs
  type DivisionError (line 21) | pub struct DivisionError;

FILE: util/libeir_util_number/src/number.rs
  type Number (line 7) | pub enum Number {
    method is_zero (line 13) | pub fn is_zero(&self) -> bool {
    method plus (line 19) | pub fn plus(self) -> Self {
    method equals (line 25) | pub fn equals(&self, rhs: &Number, exact: bool) -> bool {
    method to_efloat (line 42) | pub fn to_efloat(&self) -> Result<Float, FloatError> {
    method from (line 86) | fn from(int: Integer) -> Number {
    method from (line 91) | fn from(int: usize) -> Number {
    method from (line 96) | fn from(float: Float) -> Number {
  method eq (line 51) | fn eq(&self, rhs: &Number) -> bool {
  method partial_cmp (line 58) | fn partial_cmp(&self, other: &Number) -> Option<Ordering> {
  method cmp (line 63) | fn cmp(&self, other: &Number) -> Ordering {
  type Output (line 102) | type Output = Number;
  method neg (line 103) | fn neg(self) -> Number {
  type Output (line 112) | type Output = Result<Number, FloatError>;
  function add (line 113) | fn add(self, rhs: &Number) -> Self::Output {
  type Output (line 125) | type Output = Result<Number, FloatError>;
  function sub (line 126) | fn sub(self, rhs: &Number) -> Self::Output {
  type Output (line 138) | type Output = Result<Number, FloatError>;
  function mul (line 139) | fn mul(self, rhs: &Number) -> Self::Output {
  type Output (line 151) | type Output = Result<Number, FloatError>;
  function div (line 152) | fn div(self, rhs: &Number) -> Self::Output {

FILE: util/libeir_util_parse/src/errors.rs
  type ErrorOrWarning (line 12) | pub enum ErrorOrWarning<E, W> {
  method to_diagnostic (line 21) | fn to_diagnostic(&self) -> Diagnostic {
  type Errors (line 30) | pub struct Errors<E, W> {
  function new (line 36) | pub fn new() -> Self {
  function failed (line 43) | pub fn failed(&self) -> bool {
  function print (line 47) | pub fn print(&self, codemap: &CodeMap)
  function iter_diagnostics (line 61) | pub fn iter_diagnostics<'a>(&'a self) -> impl Iterator<Item = Diagnostic...
  function errors_from (line 69) | pub fn errors_from<IE, IW>(&mut self, other: Errors<IE, IW>)
  type MessageIgnore (line 104) | pub struct MessageIgnore<E, W> {
  function new (line 110) | pub fn new() -> Self {
  function failed (line 117) | pub fn failed(&self) -> bool {
  type ErrorReceiver (line 135) | pub trait ErrorReceiver {
    type E (line 87) | type E = E;
    type W (line 88) | type W = W;
    method is_failed (line 90) | fn is_failed(&self) -> bool {
    method warning (line 94) | fn warning(&mut self, warning: W) {
    method error (line 98) | fn error(&mut self, error: E) {
    type E (line 123) | type E = E;
    type W (line 124) | type W = W;
    method is_failed (line 126) | fn is_failed(&self) -> bool {
    method warning (line 129) | fn warning(&mut self, _warning: W) {}
    method error (line 130) | fn error(&mut self, _error: E) {
    method is_failed (line 139) | fn is_failed(&self) -> bool;
    method warning (line 140) | fn warning(&mut self, warning: Self::W);
    method error (line 141) | fn error(&mut self, error: Self::E);
    type E (line 145) | type E = E;
    type W (line 146) | type W = W;
    method is_failed (line 147) | fn is_failed(&self) -> bool {
    method warning (line 150) | fn warning(&mut self, warning: Self::W) {
    method error (line 153) | fn error(&mut self, error: Self::E) {
    type E (line 215) | type E = E;
    type W (line 216) | type W = W;
    method is_failed (line 218) | fn is_failed(&self) -> bool {
    method error (line 221) | fn error(&mut self, error: E) {
    method warning (line 226) | fn warning(&mut self, warning: W) {
    type E (line 241) | type E = OE;
    type W (line 242) | type W = OW;
    method is_failed (line 244) | fn is_failed(&self) -> bool {
    method error (line 247) | fn error(&mut self, error: OE) {
    method warning (line 252) | fn warning(&mut self, warning: OW) {
  function error_tee (line 158) | pub fn error_tee<'a, E, W, F, R>(
  type ErrorReceiverTee (line 171) | pub struct ErrorReceiverTee<'a, E, W> {
  method clone (line 175) | fn clone(&self) -> Self {
  function make_adapter (line 183) | pub fn make_adapter<NE, NW, FE, FW>(
  function make_into_adapter (line 200) | pub fn make_into_adapter<NE, NW>(&mut self) -> ErrorReceiverTeeAdapter<'...
  type ErrorReceiverTeeAdapter (line 233) | pub struct ErrorReceiverTeeAdapter<'a, IE, IW, OE, OW> {
  method clone (line 260) | fn clone(&self) -> Self {
  function basic_usage (line 275) | fn basic_usage() {

FILE: util/libeir_util_parse/src/parser.rs
  type Parser (line 9) | pub struct Parser<C> {
  function new (line 15) | pub fn new(config: C, codemap: Arc<CodeMap>) -> Self {
  function parse (line 21) | pub fn parse<'a, T>(
  function parse_string (line 32) | pub fn parse_string<'a, T, S>(
  function parse_file (line 46) | pub fn parse_file<'a, T, S>(
  type Parse (line 70) | pub trait Parse<T = Self> {
    method root_file_error (line 76) | fn root_file_error(err: std::io::Error, path: PathBuf) -> Self::Error;
    method parse (line 79) | fn parse<'a, S>(
    method parse_tokens (line 88) | fn parse_tokens<'a, S>(

FILE: util/libeir_util_parse/src/result.rs
  type ParseResult (line 5) | pub enum ParseResult<R, E> {
  type Print (line 11) | pub trait Print {
    method print (line 12) | fn print(&self);
  function unwrap (line 16) | pub fn unwrap(self) -> R {
  function unwrap_print (line 26) | pub fn unwrap_print(self) -> R

FILE: util/libeir_util_parse/src/scanner.rs
  type Scanner (line 18) | pub struct Scanner<S> {
  function new (line 29) | pub fn new(mut source: S) -> Self {
  function start (line 44) | pub fn start(&self) -> SourceIndex {
  function advance (line 52) | pub fn advance(&mut self) {
  function pop (line 62) | pub fn pop(&mut self) -> (SourceIndex, char) {
  function peek (line 70) | pub fn peek(&self) -> (SourceIndex, char) {
  function peek_next (line 76) | pub fn peek_next(&mut self) -> (SourceIndex, char) {
  function read (line 85) | pub fn read(&self) -> (SourceIndex, char) {
  function slice (line 90) | pub fn slice(&self, span: impl Into<Range<usize>>) -> &str {

FILE: util/libeir_util_parse/src/source.rs
  type SourceResult (line 10) | pub type SourceResult<T> = std::result::Result<T, SourceError>;
  type Source (line 12) | pub trait Source: Sized {
    method new (line 13) | fn new(src: Arc<SourceFile>) -> Self;
    method read (line 15) | fn read(&mut self) -> Option<(SourceIndex, char)>;
    method peek (line 17) | fn peek(&mut self) -> Option<(SourceIndex, char)>;
    method span (line 19) | fn span(&self) -> SourceSpan;
    method slice (line 21) | fn slice(&self, span: impl Into<Range<usize>>) -> &str;
    method new (line 176) | fn new(src: Arc<SourceFile>) -> Self {
    method read (line 196) | fn read(&mut self) -> Option<(SourceIndex, char)> {
    method peek (line 201) | fn peek(&mut self) -> Option<(SourceIndex, char)> {
    method span (line 206) | fn span(&self) -> SourceSpan {
    method slice (line 211) | fn slice(&self, span: impl Into<Range<usize>>) -> &str {
  type SourceError (line 25) | pub enum SourceError {
    method to_diagnostic (line 41) | pub fn to_diagnostic(&self) -> Diagnostic {
  type FileMapSource (line 55) | pub struct FileMapSource {
    method peek_char (line 65) | fn peek_char(&self) -> Option<(SourceIndex, char)> {
    method next_char (line 69) | fn next_char(&mut self) -> Option<(SourceIndex, char)> {
    method next_char_internal (line 91) | unsafe fn next_char_internal(&mut self) -> Option<(SourceIndex, char)> {
    method utf8_first_byte (line 162) | fn utf8_first_byte(byte: u8, width: u32) -> u32 {
    method utf8_acc_cont_byte (line 168) | fn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 {
    constant CONT_MASK (line 173) | const CONT_MASK: u8 = 0b0011_1111;
  type Item (line 217) | type Item = (SourceIndex, char);
  method next (line 219) | fn next(&mut self) -> Option<Self::Item> {
  function read_all_chars (line 230) | fn read_all_chars(source: FileMapSource) -> Vec<char> {
  function file_source (line 235) | fn file_source() {

FILE: util/libeir_util_parse/src/util.rs
  type PathVariableSubstituteError (line 9) | pub enum PathVariableSubstituteError {
    method to_diagnostic (line 16) | pub fn to_diagnostic(&self) -> Diagnostic {
  function substitute_path_variables (line 36) | pub fn substitute_path_variables<P: AsRef<Path>>(

FILE: util/libeir_util_parse_listing/build.rs
  function main (line 3) | fn main() {

FILE: util/libeir_util_parse_listing/src/ast.rs
  type Root (line 6) | pub struct Root {
    method span (line 10) | pub fn span(&self) -> SourceSpan {
  type Item (line 19) | pub enum Item {
    method tuple (line 30) | pub fn tuple(&self) -> Option<&Tuple> {
    method atom (line 37) | pub fn atom(&self) -> Option<Ident> {
    method string (line 44) | pub fn string(&self) -> Option<Ident> {
    method integer (line 51) | pub fn integer(&self) -> Option<&Int> {
    method float (line 58) | pub fn float(&self) -> Option<&Float> {
    method list (line 65) | pub fn list(&self) -> Option<&List> {
    method list_iter (line 72) | pub fn list_iter(&self) -> Option<impl Iterator<Item = &Item>> {
    method span (line 79) | pub fn span(&self) -> SourceSpan {
  type ListIterator (line 91) | pub struct ListIterator<'a> {
  type Item (line 96) | type Item = &'a Item;
  method next (line 97) | fn next(&mut self) -> Option<Self::Item> {
  type Int (line 123) | pub struct Int {
  type Float (line 129) | pub struct Float {
  type Tuple (line 135) | pub struct Tuple {
  type List (line 141) | pub struct List {

FILE: util/libeir_util_parse_listing/src/parser.rs
  type ParseError (line 27) | pub enum ParseError {
    method new (line 35) | pub fn new(err: lalrpop_util::ParseError<SourceIndex, Token, ()>) -> S...
    method from (line 40) | fn from(err: lalrpop_util::ParseError<SourceIndex, Token, ()>) -> Self {
  method to_diagnostic (line 46) | fn to_diagnostic(&self) -> Diagnostic {
  type Parser (line 89) | type Parser = grammar::RootParser;
  type Error (line 90) | type Error = ParseError;
  type Config (line 91) | type Config = ();
  type Token (line 92) | type Token = Result<(SourceIndex, Token, SourceIndex), ()>;
  method root_file_error (line 94) | fn root_file_error(source: std::io::Error, path: std::path::PathBuf) -> ...
  method parse (line 98) | fn parse<S>(
  method parse_tokens (line 111) | fn parse_tokens<S>(
  function fail_with (line 137) | fn fail_with<E, W>(errors: &Errors<E, W>, codemap: &CodeMap) -> !
  function parse (line 152) | fn parse<T, S>(input: S) -> T
  function simple (line 166) | fn simple() {
  function basic_ast (line 175) | fn basic_ast() {

FILE: util/libeir_util_parse_listing/src/token.rs
  type Token (line 19) | pub enum Token {
  type Float (line 37) | pub struct Float(pub f64);
  type Lexer (line 40) | pub struct Lexer<S> {
  function new (line 54) | pub fn new(scanner: Scanner<S>) -> Self {
  function lex (line 69) | pub fn lex(&mut self) -> Option<<Self as Iterator>::Item> {
  function advance (line 86) | fn advance(&mut self) {
  function advance_start (line 91) | fn advance_start(&mut self) {
  function pop (line 113) | fn pop(&mut self) -> char {
  function peek (line 119) | fn peek(&mut self) -> char {
  function read (line 123) | fn read(&mut self) -> char {
  function skip (line 127) | fn skip(&mut self) {
  function span (line 131) | pub fn span(&self) -> SourceSpan {
  function slice (line 135) | fn slice(&self) -> &str {
  function skip_whitespace (line 139) | fn skip_whitespace(&mut self) {
  function lex_unquoted_atom (line 145) | fn lex_unquoted_atom(&mut self) -> Token {
  function lex_quoted_atom (line 162) | fn lex_quoted_atom(&mut self) -> Token {
  function lex_string (line 185) | fn lex_string(&mut self) -> Token {
  function lex_number (line 208) | fn lex_number(&mut self) -> Token {
  function lex_float (line 231) | fn lex_float(&mut self) -> Token {
  function tokenize (line 246) | fn tokenize(&mut self) -> Token {
  type Item (line 279) | type Item = Result<(SourceIndex, Token, SourceIndex), ()>;
  method next (line 281) | fn next(&mut self) -> Option<Self::Item> {

FILE: util/libeir_util_pattern_compiler/src/cfg/generate_dot.rs
  constant DOT_BREAK (line 9) | const DOT_BREAK: &str = "<br align=\"left\" />";
  function format_label (line 11) | fn format_label(label: &str) -> String {
  function to_dot (line 22) | pub fn to_dot(&self, w: &mut dyn Write) -> ::std::io::Result<()> {

FILE: util/libeir_util_pattern_compiler/src/cfg/mod.rs
  type CfgNodeIndex (line 10) | pub type CfgNodeIndex = NodeIndex;
  type PatternCfg (line 18) | pub struct PatternCfg<P>
  function new (line 31) | pub(crate) fn new() -> Self {
  function add_fail (line 40) | pub(crate) fn add_fail(&mut self) -> CfgNodeIndex {
  function add_leaf (line 44) | pub(crate) fn add_leaf(
  function get_entry (line 57) | pub fn get_entry(&self) -> CfgNodeIndex {
  function add_edge (line 65) | pub(crate) fn add_edge(&mut self, parent: CfgNodeIndex, child: CfgNodeIn...
  function add_child (line 69) | pub(crate) fn add_child(
  type CfgEdge (line 84) | pub struct CfgEdge<P>
  function fmt (line 97) | fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
  type CfgNodeKind (line 107) | pub enum CfgNodeKind<CVT> {

FILE: util/libeir_util_pattern_compiler/src/lib.rs
  constant TARGET (line 26) | const TARGET: &'static str = "pattern_compiler";
  type LeafId (line 29) | struct LeafId(usize);
  type MatchCompileContext (line 32) | pub struct MatchCompileContext<'a, P>
  function new (line 47) | pub fn new(pattern: &'a mut P) -> Self {
  function root_matrix (line 66) | fn root_matrix(&self) -> &matrix::MatchMatrix<P> {
  function matrix_to_decision_tree (line 71) | fn matrix_to_decision_tree<P>(
  function to_decision_tree (line 162) | pub fn to_decision_tree<P>(pattern: &mut P) -> cfg::PatternCfg<P>

FILE: util/libeir_util_pattern_compiler/src/matrix.rs
  type MatchMatrix (line 16) | pub(crate) struct MatchMatrix<P>
  type MatchMatrixElement (line 30) | pub struct MatchMatrixElement<P>
  function new (line 55) | pub fn new(
  function with_bindings (line 64) | fn with_bindings(
  function select_specialize_variable (line 113) | pub fn select_specialize_variable(&self, pattern: &P) -> usize {
  function get_var (line 136) | pub fn get_var(&self, var: usize) -> P::CfgVariable {
  function collect_specialization_types (line 141) | pub fn collect_specialization_types<'a>(
  function specialize (line 159) | pub fn specialize(
  function without_head (line 316) | pub fn without_head<'a>(&'a self) -> MatchMatrix<P> {
  function binds_for (line 334) | pub(crate) fn binds_for<'a>(
  function binds_for_head (line 345) | pub(crate) fn binds_for_head<'a>(&'a self) -> &'a HashMap<P::PatternNode...
  function default (line 356) | pub fn default(
  function is_empty (line 365) | pub fn is_empty(&self) -> bool {
  function has_wildcard_head (line 369) | pub(crate) fn has_wildcard_head(&self, pattern: &P) -> Option<LeafId> {
  function to_table (line 390) | pub fn to_table(&self, pat: &P) -> Table {

FILE: util/libeir_util_pattern_compiler/src/pattern.rs
  type ExpandedClauseNodes (line 6) | pub struct ExpandedClauseNodes<V, K> {
  type PatternProvider (line 12) | pub trait PatternProvider: Debug {
    constant WILDCARD (line 26) | const WILDCARD: Self::PatternNodeKind;
    method get_root (line 28) | fn get_root(&self) -> ExpandedClauseNodes<Self::CfgVariable, Self::Pat...
    method kind_includes (line 39) | fn kind_includes(&self, kind: Self::PatternNodeKind, key: Self::Patter...
    method expand_clause_nodes (line 44) | fn expand_clause_nodes(
    method get_wildcard_node (line 50) | fn get_wildcard_node(&self) -> Self::PatternNodeKey;
    method get_kind (line 54) | fn get_kind(&self, key: Self::PatternNodeKey) -> Self::PatternNodeKind;
    method is_wildcard (line 56) | fn is_wildcard(&self, kind: Self::PatternNodeKind) -> bool {
    method get_wildcard (line 59) | fn get_wildcard(&self) -> Self::PatternNodeKind {

FILE: util/libeir_util_pattern_compiler/src/simple_pattern/mod.rs
  type CfgVar (line 10) | pub struct CfgVar(usize);
    method fmt (line 14) | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  type NodeKind (line 20) | pub enum NodeKind {
  type SimplePatternProvider (line 29) | pub struct SimplePatternProvider {
    method new (line 38) | pub fn new() -> Self {
    method add_child (line 50) | pub fn add_child(&mut self, node: NodeIndex, kind: NodeKind) -> NodeIn...
    method add_clause (line 56) | pub fn add_clause(&mut self, kind: NodeKind) -> NodeIndex {
  type PatternNodeKey (line 64) | type PatternNodeKey = NodeIndex;
  type PatternNodeKind (line 65) | type PatternNodeKind = NodeKind;
  type CfgVariable (line 66) | type CfgVariable = CfgVar;
  constant WILDCARD (line 68) | const WILDCARD: NodeKind = NodeKind::Wildcard;
  method get_root (line 70) | fn get_root(&self) -> ExpandedClauseNodes<Self::CfgVariable, Self::Patte...
  method kind_includes (line 78) | fn kind_includes(&self, kind: Self::PatternNodeKind, key: Self::PatternN...
  method expand_clause_nodes (line 82) | fn expand_clause_nodes(
  method get_kind (line 150) | fn get_kind(&self, key: Self::PatternNodeKey) -> Self::PatternNodeKind {
  method get_wildcard_node (line 154) | fn get_wildcard_node(&self) -> Self::PatternNodeKey {

FILE: util/libeir_util_pattern_compiler/src/simple_pattern/test.rs
  function list_merge_pattern (line 4) | fn list_merge_pattern() {

FILE: util/libeir_util_prof/src/lib.rs
  type Event (line 4) | pub struct Event {
  type EventKind (line 10) | pub enum EventKind {
  type Tracer (line 17) | pub struct Tracer {

FILE: util/meta_table/src/lib.rs
  type Invariant (line 8) | struct Invariant<T: ?Sized>(*mut T);
  type MetaEntry (line 14) | pub trait MetaEntry: 'static {
    method get_type_id (line 15) | fn get_type_id(&self) -> TypeId;
  type CastFrom (line 49) | pub unsafe trait CastFrom<T> {
    method cast (line 51) | fn cast(t: &T) -> &Self;
    method cast_mut (line 54) | fn cast_mut(t: &mut T) -> &mut Self;
    method vtable (line 56) | fn vtable() -> Fat;
  type Fat (line 83) | pub struct Fat(usize);
    method from_ptr (line 86) | pub unsafe fn from_ptr<T: ?Sized>(t: *const T) -> Self {
    method create_ptr (line 102) | pub unsafe fn create_ptr<T: ?Sized>(&self, ptr: *const ()) -> *const T {
    method create_mut_ptr (line 108) | pub unsafe fn create_mut_ptr<T: ?Sized>(&self, ptr: *mut ()) -> *mut T {
  type MetaTable (line 168) | pub struct MetaTable<T: ?Sized> {
  function new (line 178) | pub fn new() -> Self {
  function register (line 185) | pub fn register<R>(&mut self)
  function get (line 215) | pub fn get<'a>(&self, res: &'a dyn MetaEntry) -> Option<&'a T> {
  function get_mut (line 226) | pub fn get_mut<'a>(&self, res: &'a mut dyn MetaEntry) -> Option<&'a mut ...
  method default (line 239) | fn default() -> Self {
  function assert_unsized (line 249) | pub fn assert_unsized<T: ?Sized>() {
  type Object (line 259) | trait Object: MetaEntry {
    method method1 (line 260) | fn method1(&self) -> i32;
    method method2 (line 262) | fn method2(&mut self, x: i32);
    method method1 (line 271) | fn method1(&self) -> i32 {
    method method2 (line 275) | fn method2(&mut self, x: i32) {
    method method1 (line 284) | fn method1(&self) -> i32 {
    method method2 (line 288) | fn method2(&mut self, x: i32) {
    method method1 (line 352) | fn method1(&self) -> i32 {
    method method2 (line 356) | fn method2(&mut self, _x: i32) {
    method method1 (line 365) | fn method1(&self) -> i32 {
    method method2 (line 369) | fn method2(&mut self, _x: i32) {
  type ImplementorA (line 267) | struct ImplementorA(i32);
  type ImplementorB (line 280) | struct ImplementorB(i32);
  type ImplementorC (line 348) | struct ImplementorC;
  type ImplementorD (line 361) | struct ImplementorD;
  function get (line 375) | fn get() {

FILE: util/scoped_cell/src/lib.rs
  type BorrowMutError (line 6) | pub struct BorrowMutError;
  type ScopedCellGuard (line 8) | struct ScopedCellGuard<'a, T: ?Sized>(&'a ScopedCell<T>);
  method drop (line 10) | fn drop(&mut self) {
  type ScopedCell (line 19) | pub struct ScopedCell<T: ?Sized> {
  function borrow_mut (line 25) | pub fn borrow_mut<F, R>(&self, fun: F) -> R
  function try_borrow_mut (line 51) | pub fn try_borrow_mut<F, R>(&self, fun: F) -> Result<R, BorrowMutError>
  function inner_mut (line 81) | unsafe fn inner_mut(&self) -> &mut ScopedCellInner<T> {
  method clone (line 87) | fn clone(&self) -> Self {
  method drop (line 99) | fn drop(&mut self) {
  type ScopedCellInner (line 121) | pub struct ScopedCellInner<T: ?Sized> {
  function new (line 139) | pub fn new<'a, T: ?Sized + 'a>(value: &'a mut T) -> ScopedCellCreatorGua...
  type ScopedCellCreatorGuard (line 175) | pub struct ScopedCellCreatorGuard<'a, T: ?Sized> {
  method drop (line 180) | fn drop(&mut self) {
  function clone_cell (line 194) | pub fn clone_cell(&self) -> ScopedCell<T> {
  function scoped_cell (line 199) | pub fn scoped_cell<T: ?Sized, F, R>(value: &mut T, fun: F) -> R
  function creation (line 214) | fn creation() {
  function basic_usage (line 220) | fn basic_usage() {
  function raw_usage (line 271) | fn raw_usage() {
  function double_borrow_fails (line 287) | fn double_borrow_fails() {