Full Code of Mercerenies/gdlisp for AI

gitextract_8xnoo2xc/

├── .github/
│   └── workflows/
│       ├── style-clippy.yml
│       ├── style-docs.yml
│       ├── test-Godotv3.3.3-Ubuntu.yml
│       ├── test-Godotv3.4-Ubuntu.yml
│       ├── test-Godotv3.5-Minimal-Ubuntu.yml
│       ├── test-Godotv3.5-Mono-Ubuntu.yml
│       └── test-Godotv3.5-Ubuntu.yml
├── .gitignore
├── .readthedocs.yaml
├── COPYING
├── Cargo.toml
├── GDLisp.lisp
├── MacroServer/
│   ├── TestLoadedFile.gd
│   ├── main.gd
│   ├── main.tscn
│   └── project.godot
├── README.md
├── Rakefile
├── build.rs
├── doc/
│   ├── README.md
│   ├── internal/
│   │   ├── CompilationStages.md
│   │   └── README.md
│   └── readthedocs/
│       ├── Makefile
│       ├── conf.py
│       ├── index.rst
│       ├── make.bat
│       ├── reference/
│       │   ├── classes.rst
│       │   ├── command-line.rst
│       │   ├── datatypes.rst
│       │   ├── expressions.rst
│       │   ├── imports.rst
│       │   ├── index.rst
│       │   ├── lambda-lists.rst
│       │   ├── macros.rst
│       │   ├── parser.rst
│       │   ├── quoting.rst
│       │   ├── source-file.rst
│       │   └── standard-library/
│       │       ├── functions.rst
│       │       ├── index.rst
│       │       ├── macros.rst
│       │       ├── types.rst
│       │       └── values.rst
│       ├── requirements.txt
│       └── tutorial/
│           ├── classes.rst
│           ├── control-flow.rst
│           ├── index.rst
│           ├── lisping.rst
│           ├── macros.rst
│           ├── modules.rst
│           └── what-now.rst
├── minimal.txt
├── src/
│   ├── command_line.rs
│   ├── compile/
│   │   ├── args.rs
│   │   ├── body/
│   │   │   ├── builder.rs
│   │   │   ├── class_initializer.rs
│   │   │   ├── class_scope.rs
│   │   │   ├── mod.rs
│   │   │   ├── super_proxy.rs
│   │   │   └── synthetic_field.rs
│   │   ├── constant.rs
│   │   ├── error.rs
│   │   ├── factory.rs
│   │   ├── frame.rs
│   │   ├── import.rs
│   │   ├── mod.rs
│   │   ├── names/
│   │   │   ├── contextual.rs
│   │   │   ├── fresh.rs
│   │   │   ├── generator.rs
│   │   │   ├── mod.rs
│   │   │   ├── registered.rs
│   │   │   └── reserved.rs
│   │   ├── preload_resolver.rs
│   │   ├── resource_type.rs
│   │   ├── special_form/
│   │   │   ├── closure.rs
│   │   │   ├── flet.rs
│   │   │   ├── lambda.rs
│   │   │   ├── lambda_class.rs
│   │   │   ├── lambda_vararg/
│   │   │   │   ├── builder.rs
│   │   │   │   └── mod.rs
│   │   │   ├── let_block.rs
│   │   │   └── mod.rs
│   │   ├── stateful.rs
│   │   ├── stmt_wrapper.rs
│   │   └── symbol_table/
│   │       ├── call_magic/
│   │       │   ├── mod.rs
│   │       │   └── table.rs
│   │       ├── function_call.rs
│   │       ├── inner.rs
│   │       ├── local_var.rs
│   │       └── mod.rs
│   ├── gdscript/
│   │   ├── arglist.rs
│   │   ├── class_extends.rs
│   │   ├── decl.rs
│   │   ├── expr.rs
│   │   ├── expr_wrapper.rs
│   │   ├── inner_class.rs
│   │   ├── library/
│   │   │   ├── cell.rs
│   │   │   ├── class_loader.rs
│   │   │   ├── constant_loader.rs
│   │   │   ├── gdnative/
│   │   │   │   ├── api_type.rs
│   │   │   │   ├── argument.rs
│   │   │   │   ├── class.rs
│   │   │   │   ├── gdnative_enum.rs
│   │   │   │   ├── method.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── property.rs
│   │   │   │   └── signal.rs
│   │   │   ├── magic.rs
│   │   │   └── mod.rs
│   │   ├── literal.rs
│   │   ├── metadata.rs
│   │   ├── mod.rs
│   │   ├── op.rs
│   │   ├── pattern.rs
│   │   ├── spacing.rs
│   │   └── stmt.rs
│   ├── graph/
│   │   ├── mod.rs
│   │   ├── tarjan.rs
│   │   └── top_sort.rs
│   ├── ir/
│   │   ├── access_type.rs
│   │   ├── arglist/
│   │   │   ├── constructor.rs
│   │   │   ├── error.rs
│   │   │   ├── general.rs
│   │   │   ├── mod.rs
│   │   │   ├── ordinary.rs
│   │   │   ├── parser.rs
│   │   │   ├── simple.rs
│   │   │   └── vararg.rs
│   │   ├── bootstrapping.rs
│   │   ├── call_name.rs
│   │   ├── classification.rs
│   │   ├── closure_names.rs
│   │   ├── decl.rs
│   │   ├── declaration_table.rs
│   │   ├── depends.rs
│   │   ├── export.rs
│   │   ├── expr.rs
│   │   ├── identifier.rs
│   │   ├── import.rs
│   │   ├── incremental.rs
│   │   ├── literal.rs
│   │   ├── loops/
│   │   │   ├── error.rs
│   │   │   └── mod.rs
│   │   ├── macros.rs
│   │   ├── main_function.rs
│   │   ├── mod.rs
│   │   ├── modifier/
│   │   │   ├── class.rs
│   │   │   ├── constant.rs
│   │   │   ├── declare.rs
│   │   │   ├── enums.rs
│   │   │   ├── file.rs
│   │   │   ├── function.rs
│   │   │   ├── instance_method.rs
│   │   │   ├── macros.rs
│   │   │   ├── magic.rs
│   │   │   ├── mod.rs
│   │   │   ├── var.rs
│   │   │   └── visibility.rs
│   │   ├── quasiquote.rs
│   │   ├── scope/
│   │   │   ├── decl.rs
│   │   │   ├── error.rs
│   │   │   ├── mod.rs
│   │   │   └── name_table/
│   │   │       ├── builder.rs
│   │   │       └── mod.rs
│   │   ├── special_form/
│   │   │   ├── access_slot.rs
│   │   │   ├── assignment.rs
│   │   │   ├── local_binding.rs
│   │   │   └── mod.rs
│   │   └── special_ref.rs
│   ├── lib.rs
│   ├── main.rs
│   ├── optimize/
│   │   ├── gdscript/
│   │   │   ├── assignment.rs
│   │   │   ├── basic_math_ops.rs
│   │   │   ├── constant.rs
│   │   │   ├── constant_conditional_branch.rs
│   │   │   ├── dead_code_elimination.rs
│   │   │   ├── dead_decl_elimination.rs
│   │   │   ├── dead_var_elimination.rs
│   │   │   ├── direct_var_substitute.rs
│   │   │   ├── else_then_if_fold.rs
│   │   │   ├── expr_walker.rs
│   │   │   ├── mod.rs
│   │   │   ├── noop.rs
│   │   │   ├── redundant_assignment_elimination.rs
│   │   │   ├── stmt_walker.rs
│   │   │   ├── ternary_if_fold.rs
│   │   │   └── variables.rs
│   │   ├── ir/
│   │   │   ├── expr_walker.rs
│   │   │   └── mod.rs
│   │   └── mod.rs
│   ├── parser.lalrpop
│   ├── parser_test.rs
│   ├── pipeline/
│   │   ├── can_load.rs
│   │   ├── config.rs
│   │   ├── error.rs
│   │   ├── loader.rs
│   │   ├── mod.rs
│   │   ├── resolver.rs
│   │   ├── source.rs
│   │   ├── stdlib_unit.rs
│   │   └── translation_unit.rs
│   ├── repl.rs
│   ├── runner/
│   │   ├── godot.rs
│   │   ├── into_gd_file.rs
│   │   ├── macro_server/
│   │   │   ├── command.rs
│   │   │   ├── lazy.rs
│   │   │   ├── mod.rs
│   │   │   ├── named_file_server.rs
│   │   │   └── response.rs
│   │   ├── mod.rs
│   │   ├── named_file.rs
│   │   ├── path.rs
│   │   └── version.rs
│   ├── sxp/
│   │   ├── ast.rs
│   │   ├── dotted.rs
│   │   ├── literal.rs
│   │   ├── mod.rs
│   │   ├── reify/
│   │   │   ├── mod.rs
│   │   │   └── pretty.rs
│   │   ├── string.rs
│   │   └── syntax.rs
│   └── util/
│       ├── debug_wrapper.rs
│       ├── group_by.rs
│       ├── lattice.rs
│       ├── lazy.rs
│       ├── mod.rs
│       ├── one.rs
│       ├── prefix_matcher.rs
│       └── recursive.rs
└── tests/
    ├── integration_tests.rs
    └── test/
        ├── builtin_function_test.rs
        ├── class_test.rs
        ├── collection_conversion_test.rs
        ├── common/
        │   ├── import.rs
        │   └── mod.rs
        ├── concurrency_test.rs
        ├── cond_if_test.rs
        ├── const_test.rs
        ├── declaration_test.rs
        ├── dependencies_test.rs
        ├── dictionary_test.rs
        ├── enum_test.rs
        ├── error_test.rs
        ├── even_odd_test.rs
        ├── factorial_test.rs
        ├── flet_test.rs
        ├── floating_test.rs
        ├── for_test.rs
        ├── import_test.rs
        ├── labels_test.rs
        ├── lambda_class_test.rs
        ├── lambda_test.rs
        ├── lazy_val_test.rs
        ├── let_var_test.rs
        ├── list_operator_test.rs
        ├── macro_test.rs
        ├── meta_test.rs
        ├── mod.rs
        ├── name_translation_test.rs
        ├── object_test.rs
        ├── operator_test.rs
        ├── quoting_test.rs
        ├── signal_test.rs
        ├── simple_expr_test.rs
        ├── string_test.rs
        ├── type_checking_test.rs
        ├── typecast_test.rs
        └── while_test.rs

SYMBOL INDEX (2924 symbols across 210 files)

FILE: build.rs
  function main (line 20) | fn main() {

FILE: src/command_line.rs
  constant PROGRAM_DESCRIPTION (line 26) | const PROGRAM_DESCRIPTION: &str =
  type CommandLineArgs (line 36) | pub struct CommandLineArgs {
    method new (line 55) | pub fn new() -> CommandLineArgs {
    method help (line 61) | pub fn help() -> CommandLineArgs {
  function options (line 71) | pub fn options() -> Options {
  function parse_args (line 88) | pub fn parse_args(args: &[String]) -> CommandLineArgs {
  function show_help_message (line 107) | pub fn show_help_message(program: &str) {

FILE: src/compile/args.rs
  type Expecting (line 49) | pub struct Expecting {
    constant NONE (line 107) | pub const NONE: Expecting = Expecting { minimum: 0, maximum: 0 };
    method new (line 111) | pub fn new(minimum: usize, maximum: usize) -> Expecting {
    method between (line 116) | pub fn between(minimum: usize, maximum: usize) -> Expecting {
    method exactly (line 121) | pub fn exactly(value: usize) -> Expecting {
    method at_least (line 126) | pub fn at_least(minimum: usize) -> Expecting {
    method at_most (line 131) | pub fn at_most(maximum: usize) -> Expecting {
    method contains (line 137) | pub fn contains(&self, args_count: usize) -> bool {
    method validate_amount (line 144) | pub fn validate_amount(&self, name: &str, pos: SourceOffset, args_coun...
    method validate (line 155) | pub fn validate<T>(&self, name: &str, pos: SourceOffset, slice: &[T]) ...
    method fmt (line 230) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ExpectedShape (line 60) | pub enum ExpectedShape {
    method extract_symbol (line 165) | pub fn extract_symbol(form_name: &str, ast: AST) -> Result<String, GDE...
    method extract_string (line 175) | pub fn extract_string(form_name: &str, ast: AST) -> Result<String, GDE...
    method extract_i32 (line 185) | pub fn extract_i32(form_name: &str, ast: AST) -> Result<i32, GDError> {
    method validate_empty (line 200) | pub fn validate_empty(form_name: &str, lst: &[&AST], pos: SourceOffset...
    method validate_end_of_list (line 216) | pub fn validate_end_of_list(form_name: &str, lst: &[&AST], pos: Source...
    method fmt (line 246) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function zero (line 273) | pub fn zero<T>(args: Vec<T>) {
  function one (line 282) | pub fn one<T>(mut args: Vec<T>) -> T {
  function two (line 292) | pub fn two<T>(mut args: Vec<T>) -> (T, T) {
  function three (line 304) | pub fn three<T>(mut args: Vec<T>) -> (T, T, T) {

FILE: src/compile/body/builder.rs
  type CodeBuilder (line 26) | pub struct CodeBuilder {
    method new (line 71) | pub fn new(extends: ClassExtends) -> CodeBuilder {
    method named (line 85) | pub fn named(&mut self, name: String) {
    method extends (line 90) | pub fn extends(&mut self, extends: ClassExtends) {
    method build (line 95) | pub fn build(self) -> decl::TopLevelClass {
  type StmtBuilder (line 39) | pub struct StmtBuilder {
    method new (line 110) | pub fn new() -> StmtBuilder {
    method append (line 115) | pub fn append(&mut self, stmt: Stmt) {
    method append_all (line 120) | pub fn append_all(&mut self, stmts: &mut dyn Iterator<Item=Stmt>) {
    method add_helper (line 128) | pub fn add_helper(&mut self, decl: Decl) {
    method build (line 138) | pub fn build(self) -> (Vec<Stmt>, Vec<Decl>) {
    method build_into (line 150) | pub fn build_into(self, other: &mut impl HasDecls) -> Vec<Stmt> {
  type HasDecls (line 50) | pub trait HasDecls {
    method add_decl (line 53) | fn add_decl(&mut self, decl: Decl);
    method add_decls (line 56) | fn add_decls(&mut self, decls: impl IntoIterator<Item=Decl>) {
    method add_decl (line 102) | fn add_decl(&mut self, decl: Decl) {
    method add_decl (line 161) | fn add_decl(&mut self, decl: Decl) {

FILE: src/compile/body/class_initializer.rs
  type ClassBuilder (line 44) | pub struct ClassBuilder {
    method new (line 94) | pub fn new() -> ClassBuilder {
    method builder_for (line 100) | pub fn builder_for(&mut self, init_time: InitTime) -> &mut StmtBuilder {
    method declare_getter_for (line 113) | pub fn declare_getter_for(&mut self, field_name: String) -> Option<Str...
    method declare_setter_for (line 135) | pub fn declare_setter_for(&mut self, field_name: String) -> Option<Str...
    method declare_super_proxy (line 154) | pub fn declare_super_proxy(&mut self, gen: &mut FreshNameGenerator, su...
    method declare_proxies_from_scope (line 163) | pub fn declare_proxies_from_scope(&mut self, scope: DirectClassScope) {
    method fill_out_synthetic_fields (line 173) | pub fn fill_out_synthetic_fields(&mut self, decl: &mut ClassDecl, pos:...
    method implied_getter (line 192) | fn implied_getter(field_name: &str, method_name: &str, pos: SourceOffs...
    method implied_setter (line 203) | fn implied_setter(field_name: &str, method_name: &str, pos: SourceOffs...
    method build (line 216) | pub fn build(self) -> (ClassInit, Vec<Decl>) {
    method build_into (line 241) | pub fn build_into(self, other: &mut impl HasDecls) -> ClassInit {
  type ClassInit (line 67) | pub struct ClassInit {
    method apply (line 275) | pub fn apply(mut self, class: &mut ClassDecl, pos: SourceOffset) -> Re...
    method apply_proxy_fields (line 307) | fn apply_proxy_fields(fields: Vec<SyntheticField>, class: &mut ClassDe...
    method all_var_decls (line 323) | fn all_var_decls(class: &ClassDecl) -> HashMap<String, SourceOffset> {
    method find_initializer (line 336) | pub fn find_initializer(decls: &mut Vec<Decl>) -> &mut InitFnDecl {
    method empty_initializer (line 345) | fn empty_initializer() -> Decl {
    method find_ready (line 356) | pub fn find_ready(decls: &mut Vec<Decl>) -> &mut FnDecl {
    method empty_ready (line 365) | fn empty_ready() -> Decl {
  type InitTime (line 81) | pub enum InitTime {
  method add_decl (line 253) | fn add_decl(&mut self, decl: Decl) {
  method default (line 263) | fn default() -> InitTime {

FILE: src/compile/body/class_scope.rs
  type OutsideOfClass (line 35) | pub struct OutsideOfClass;
  type ClassScopeMut (line 39) | pub struct ClassScopeMut<'a>(pub &'a mut dyn ClassScope);
  type DirectClassScope (line 46) | pub struct DirectClassScope {
    method new (line 82) | pub fn new() -> DirectClassScope {
    method into_proxies (line 88) | pub fn into_proxies(self) -> Vec<SuperProxy> {
    method add_proxy (line 93) | pub fn add_proxy(&mut self, proxy: SuperProxy) {
  type ClosedClassScope (line 54) | pub struct ClosedClassScope<'a>(pub &'a mut DirectClassScope);
  type ClassScope (line 59) | pub trait ClassScope {
    method super_call (line 64) | fn super_call(&mut self,
    method closure_mut (line 74) | fn closure_mut(&mut self) -> Box<dyn ClassScope + '_>;
    method super_call (line 101) | fn super_call(&mut self,
    method closure_mut (line 112) | fn closure_mut(&mut self) -> Box<dyn ClassScope + '_> {
    method super_call (line 120) | fn super_call(&mut self,
    method closure_mut (line 131) | fn closure_mut(&mut self) -> Box<dyn ClassScope + '_> {
    method super_call (line 141) | fn super_call(&mut self,
    method closure_mut (line 151) | fn closure_mut(&mut self) -> Box<dyn ClassScope + '_> {
    method super_call (line 160) | fn super_call(&mut self,
    method closure_mut (line 175) | fn closure_mut(&mut self) -> Box<dyn ClassScope + '_> {

FILE: src/compile/body/super_proxy.rs
  type SuperProxy (line 34) | pub struct SuperProxy {
    constant PROXY_NAME (line 50) | pub const PROXY_NAME: &'static str = "__gdlisp_super";
    method generate (line 56) | pub fn generate(gen: &mut FreshNameGenerator, super_name: String, args...
  method from (line 66) | fn from(proxy: SuperProxy) -> FnDecl {

FILE: src/compile/body/synthetic_field.rs
  type SyntheticField (line 29) | pub struct SyntheticField {
    method new (line 57) | pub fn new() -> SyntheticField {
    method into_field (line 64) | pub fn into_field(self) -> VarDecl {
  type Getter (line 41) | pub struct Getter {
    method new (line 76) | pub fn new(name: String, body: Vec<Stmt>) -> Getter {
    method method_name (line 83) | pub fn method_name(field_name: &str) -> String {
  type Setter (line 49) | pub struct Setter {
    method new (line 92) | pub fn new(name: String, argument_name: String, body: Vec<Stmt>) -> Se...
    method method_name (line 99) | pub fn method_name(field_name: &str) -> String {
  method from (line 107) | fn from(getter: Getter) -> FnDecl {
  method from (line 119) | fn from(setter: Setter) -> FnDecl {

FILE: src/compile/constant.rs
  constant CONSTANT_GDSCRIPT_FUNCTIONS (line 40) | pub const CONSTANT_GDSCRIPT_FUNCTIONS: phf::Set<&'static str> = phf_set! {
  function validate_all_constant_scopes (line 47) | pub fn validate_all_constant_scopes(decls: &[Decl], table: &SymbolTable)...
  function validate_constant_names_in_class (line 77) | fn validate_constant_names_in_class(inner_decls: &[ClassInnerDecl], tabl...
  function is_const_expr (line 102) | pub fn is_const_expr(expr: &IRExpr, table: &SymbolTable) -> bool {
  function validate_const_expr (line 106) | pub fn validate_const_expr(name: &str, expr: &IRExpr, table: &SymbolTabl...
  function validate_const_var_name (line 227) | fn validate_const_var_name(name: &str, var_name: &str, table: &SymbolTab...
  function validate_const_call (line 237) | fn validate_const_call(name: &str, object: &CallTarget, function_name: &...
  function validate_scoped_const_call (line 259) | fn validate_scoped_const_call(name: &str, function_name: &str, arg_count...
  function is_name_of_enum (line 280) | fn is_name_of_enum(lhs: &IRExpr, table: &SymbolTable) -> bool {
  function non_constant_error (line 294) | fn non_constant_error<T>(name: &str, pos: SourceOffset) -> Result<T, GDE...

FILE: src/compile/error.rs
  type GDErrorF (line 48) | pub enum GDErrorF {
    method error_number (line 324) | pub fn error_number(&self) -> u32 {
    method is_internal (line 416) | pub fn is_internal(&self) -> bool {
    method fmt (line 433) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 629) | fn from(_: sxp::dotted::TryFromDottedExprError) -> GDErrorF {
    method from (line 641) | fn from(err: ArgListParseError) -> GDErrorF {
    method from (line 654) | fn from(err: ImportDeclParseError) -> GDErrorF {
    method from (line 660) | fn from(err: ImportNameResolutionError) -> GDErrorF {
    method from (line 673) | fn from(err: VarNameIntoExtendsError) -> GDErrorF {
    method from (line 679) | fn from(err: response::Failure) -> GDErrorF {
    method from (line 685) | fn from(err: ModifierParseError) -> GDErrorF {
  type GDError (line 284) | pub struct GDError {
    method new (line 294) | pub fn new(value: GDErrorF, pos: SourceOffset) -> GDError {
    method from_value (line 300) | pub fn from_value<T>(value: T, pos: SourceOffset) -> GDError
    method error_number (line 307) | pub fn error_number(&self) -> u32 {
    method is_internal (line 313) | pub fn is_internal(&self) -> bool {
    method fmt (line 586) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 635) | fn from(err: sxp::dotted::TryFromDottedExprError) -> GDError {
    method from (line 647) | fn from(err: ArgListParseError) -> GDError {
    method from (line 691) | fn from(err: ModifierParseError) -> GDError {
    method from (line 698) | fn from(err: DuplicateMainClassError) -> GDError {
    method from (line 704) | fn from(err: ScopeError<ClassNamespace>) -> GDError {
    method from (line 715) | fn from(err: ScopeError<Namespace>) -> GDError {
    method from (line 723) | fn from(e: DependencyError) -> GDError {
    method from (line 737) | fn from(err: LoopPrimitiveError) -> GDError {
  constant INTERNAL_ERROR_NOTE (line 289) | const INTERNAL_ERROR_NOTE: &str = "Note: Unless you're doing something r...
  method source (line 593) | fn source(&self) -> Option<&(dyn Error + 'static)> {
  type Item (line 616) | type Item = GDErrorF;
  method get_source (line 618) | fn get_source(&self) -> SourceOffset {
  method get_value (line 622) | fn get_value(&self) -> &GDErrorF {

FILE: src/compile/factory.rs
  type IRLiteral (line 46) | type IRLiteral = ir::literal::Literal;
  type IRExpr (line 47) | type IRExpr = ir::expr::Expr;
  type IRArgList (line 48) | type IRArgList = ir::arglist::ordinary::ArgList;
  type DeclaredFnWithInit (line 51) | struct DeclaredFnWithInit {
  function declare_var (line 60) | pub fn declare_var(gen: &mut impl NameGenerator,
  function flatten_class_into_main (line 81) | pub fn flatten_class_into_main(import_table: &ImportTable, builder: &mut...
  function transform_extends_path_for_main (line 90) | fn transform_extends_path_for_main(import_table: &ImportTable, extends: ...
  function declare_function (line 109) | pub fn declare_function(frame: &mut CompilerFrame<impl HasDecls>,
  function declare_function_with_init (line 120) | fn declare_function_with_init(frame: &mut CompilerFrame<impl HasDecls>,
  function declare_class (line 173) | pub fn declare_class(frame: &mut CompilerFrame<impl HasDecls>,
  function declare_constructor (line 260) | pub fn declare_constructor(frame: &mut CompilerFrame<impl HasDecls>,
  function make_instance_var_initializer (line 321) | fn make_instance_var_initializer(instance_var_name: &str, local_var_name...
  function compile_literal (line 332) | pub fn compile_literal(literal: &IRLiteral, pos: SourceOffset) -> Expr {

FILE: src/compile/frame.rs
  type IRExpr (line 57) | type IRExpr = ir::expr::Expr;
  type IRExprF (line 58) | type IRExprF = ir::expr::ExprF;
  type IRDecl (line 59) | type IRDecl = ir::decl::Decl;
  type IRDeclF (line 60) | type IRDeclF = ir::decl::DeclF;
  type IRArgList (line 61) | type IRArgList = ir::arglist::ordinary::ArgList;
  constant MAX_QUOTE_REIFY_DEPTH (line 69) | pub const MAX_QUOTE_REIFY_DEPTH: u32 = 4;
  type CompilerFrame (line 95) | pub struct CompilerFrame<'a, 'b, 'c, 'd, 'e, B> {
  function new (line 131) | pub fn new(compiler: &'a mut Compiler,
  function name_generator (line 141) | pub fn name_generator(&mut self) -> &mut FreshNameGenerator {
  function preload_resolver (line 146) | pub fn preload_resolver(&self) -> &dyn PreloadResolver {
  function with_builder (line 154) | pub fn with_builder<B1, R, F>(&mut self, new_builder: &mut B1, block: F)...
  function compile_simple_expr (line 170) | pub fn compile_simple_expr(&mut self,
  function with_local_builder_value (line 202) | pub fn with_local_builder_value<R, F>(&mut self, block: F) -> (R, Vec<St...
  function with_local_builder_result (line 215) | pub fn with_local_builder_result<R, F>(&mut self, block: F) -> Result<(R...
  function with_local_builder (line 226) | pub fn with_local_builder<F>(&mut self, block: F) -> Result<Vec<Stmt>, G...
  function with_local_builder_ok (line 237) | pub fn with_local_builder_ok<F>(&mut self, block: F) -> Vec<Stmt>
  function compile_toplevel (line 247) | pub fn compile_toplevel(&mut self, toplevel: &ir::decl::TopLevel) -> Res...
  function compile_decls (line 260) | pub fn compile_decls(&mut self, decls: &[IRDecl]) -> Result<(), GDError> {
  function compile_decl (line 280) | pub fn compile_decl(&mut self, decl: &IRDecl) -> Result<(), GDError> {
  function compile_stmts (line 373) | pub fn compile_stmts(&mut self,
  function compile_stmt (line 400) | pub fn compile_stmt(&mut self,
  function compile_expr (line 411) | pub fn compile_expr(&mut self,
  function compile_bare_name (line 557) | fn compile_bare_name(&mut self,
  function compile_function_call (line 573) | fn compile_function_call(&mut self,
  function compile_ordinary_function_call (line 623) | pub fn compile_ordinary_function_call(&mut self,
  function compile_special_ref (line 647) | pub fn compile_special_ref(&mut self, special_ref: SpecialRef, pos: Sour...
  function compile_assignment (line 678) | fn compile_assignment(&mut self,
  method get_symbol_table (line 718) | fn get_symbol_table(&self) -> &SymbolTable {
  method get_symbol_table_mut (line 722) | fn get_symbol_table_mut(&mut self) -> &mut SymbolTable {

FILE: src/compile/import.rs
  type ImportTable (line 27) | pub struct ImportTable {
    method new (line 34) | pub fn new() -> ImportTable {
    method get (line 39) | pub fn get(&self, name: &str) -> Option<&str> {
    method set (line 45) | pub fn set(&mut self, name: String, value: String) {
    method del (line 50) | pub fn del(&mut self, name: &str) {
    method into_hashmap (line 55) | pub fn into_hashmap(self) -> HashMap<String, String> {

FILE: src/compile/mod.rs
  type IRDecl (line 71) | type IRDecl = ir::decl::Decl;
  type IRDeclF (line 72) | type IRDeclF = ir::decl::DeclF;
  type IRExpr (line 73) | type IRExpr = ir::expr::Expr;
  type IRExprF (line 74) | type IRExprF = ir::expr::ExprF;
  type IRArgList (line 75) | type IRArgList = ir::arglist::ordinary::ArgList;
  type Compiler (line 77) | pub struct Compiler {
    method new (line 89) | pub fn new(gen: FreshNameGenerator, resolver: Box<dyn PreloadResolver>...
    method nil_expr (line 95) | pub fn nil_expr(pos: SourceOffset) -> StExpr {
    method name_generator (line 99) | pub fn name_generator(&mut self) -> &mut FreshNameGenerator {
    method preload_resolver (line 103) | pub fn preload_resolver(&self) -> &dyn PreloadResolver {
    method import_path_table (line 107) | pub fn import_path_table(&self) -> &ImportTable {
    method is_minimalist (line 111) | pub fn is_minimalist(&self) -> bool {
    method frame (line 115) | pub fn frame<'a, 'b, 'c, 'd, 'e, B>(&'a mut self,
    method compile_export (line 124) | fn compile_export(&mut self,
    method compile_class_inner_decl (line 143) | pub fn compile_class_inner_decl(&mut self,
    method compile_inner_var_value (line 257) | fn compile_inner_var_value(name: &str,
    method resolve_extends (line 300) | pub fn resolve_extends(table: &SymbolTable, extends: &str, pos: Source...
    method bind_decl (line 309) | fn bind_decl(magic_table: &MagicTable,
    method make_preload_line (line 437) | fn make_preload_line(&self, var: String, path: &RPathBuf, pos: SourceO...
    method get_preload_resolved_path (line 445) | fn get_preload_resolved_path(&self, path: &RPathBuf, pos: SourceOffset...
    method make_preload_expr (line 456) | pub fn make_preload_expr(&self, path: &RPathBuf, pos: SourceOffset) ->...
    method import_name (line 472) | fn import_name(&mut self, import: &ImportDecl) -> String {
    method translate_call (line 480) | pub fn translate_call(import_name: String, mut call: function_call::Fn...
    method resolve_import (line 487) | pub fn resolve_import(&mut self,
  function int (line 575) | fn int(n: i32) -> AST {
  function nil (line 579) | fn nil() -> AST {
  function cons (line 584) | fn cons(a: AST, b: AST) -> AST {
  function list (line 588) | fn list(data: Vec<AST>) -> AST {
  function e (line 592) | fn e(expr: ExprF) -> Expr {
  function s (line 596) | fn s(stmt: StmtF) -> Stmt {
  function bind_helper_symbols (line 600) | fn bind_helper_symbols(table: &mut SymbolTable) {
  function compile_stmt (line 609) | fn compile_stmt(ast: &AST) -> Result<(Vec<Stmt>, Vec<Decl>), PError> {
  function compile_var (line 633) | fn compile_var() {
  function compile_call (line 642) | fn compile_call() {
  function compile_int (line 651) | fn compile_int() {
  function compile_bool_t (line 660) | fn compile_bool_t() {
  function compile_bool_f (line 669) | fn compile_bool_f() {
  function compile_string (line 678) | fn compile_string() {
  function compile_progn_vacuous (line 687) | fn compile_progn_vacuous() {
  function compile_progn_stateful (line 696) | fn compile_progn_stateful() {
  function compile_nil (line 708) | fn compile_nil() {

FILE: src/compile/names/contextual.rs
  type ContextualNameGenerator (line 39) | pub struct ContextualNameGenerator<'a> {
  function new (line 47) | pub fn new(context: &SymbolTable, namespace: Namespace) -> ContextualNam...
  function is_name_in_use (line 51) | fn is_name_in_use(&self, name: &str) -> bool {
  method generate_with (line 62) | fn generate_with(&mut self, prefix: &str) -> String {
  function empty_generate (line 79) | fn empty_generate() {
  function contextual_generate (line 88) | fn contextual_generate() {

FILE: src/compile/names/fresh.rs
  type FreshNameGenerator (line 34) | pub struct FreshNameGenerator {
    method new (line 55) | pub fn new(reserved: Vec<&str>) -> FreshNameGenerator {
    method to_json (line 66) | pub fn to_json(&self) -> JsonValue {
    method from_json (line 79) | pub fn from_json(value: &JsonValue) -> Result<Self, ParseError> {
  type ParseError (line 46) | pub enum ParseError {
  method generate_with (line 109) | fn generate_with(&mut self, prefix: &str) -> String {
  function empty_generate (line 128) | fn empty_generate() {
  function unrelated_generate (line 136) | fn unrelated_generate() {
  function conflicting_generate (line 144) | fn conflicting_generate() {
  function custom_prefix (line 152) | fn custom_prefix() {
  function through_json (line 160) | fn through_json() {

FILE: src/compile/names/generator.rs
  type NameGenerator (line 23) | pub trait NameGenerator {
    method generate_with (line 26) | fn generate_with(&mut self, prefix: &str) -> String;
    method generate (line 31) | fn generate(&mut self) -> String {
  constant DEFAULT_PREFIX (line 39) | pub const DEFAULT_PREFIX: &str = "_G";

FILE: src/compile/names/mod.rs
  constant TRANSLATIONS (line 34) | const TRANSLATIONS: phf::Map<char, &'static str> = phf_map! {
  type NameTrans (line 59) | pub struct NameTrans {
  function is_valid_gd_char (line 72) | pub fn is_valid_gd_char(ch: char) -> bool {
  function lisp_to_gd (line 136) | pub fn lisp_to_gd(name: &str) -> String {
  function lisp_to_gd_bare (line 157) | pub fn lisp_to_gd_bare(name: &str) -> String {
  function special_cases (line 199) | fn special_cases() {
  function translations (line 206) | fn translations() {
  function starts_with_number (line 227) | fn starts_with_number() {
  function keywords (line 233) | fn keywords() {
  function special_cases_bare (line 242) | fn special_cases_bare() {
  function translations_bare (line 249) | fn translations_bare() {
  function keywords_bare (line 256) | fn keywords_bare() {
  function translations_unicode (line 265) | fn translations_unicode() {

FILE: src/compile/names/registered.rs
  type RegisteredNameGenerator (line 36) | pub struct RegisteredNameGenerator<'a> {
  function new_fn (line 45) | pub fn new_fn(context: &mut SymbolTable) -> RegisteredNameGenerator<'_> {
  function new_local_var (line 54) | pub fn new_local_var(context: &mut SymbolTable) -> RegisteredNameGenerat...
  function new_global_var (line 63) | pub fn new_global_var(context: &mut SymbolTable) -> RegisteredNameGenera...
  function register_name (line 71) | fn register_name(&mut self, name: String) {
  method generate_with (line 82) | fn generate_with(&mut self, prefix: &str) -> String {

FILE: src/compile/names/reserved.rs
  constant GDSCRIPT_KEYWORDS (line 28) | const GDSCRIPT_KEYWORDS: [&str; 42] = [
  constant GDSCRIPT_FUNCTIONS (line 39) | const GDSCRIPT_FUNCTIONS: [&str; 93] = [
  constant GLOBAL_CONSTANTS (line 58) | const GLOBAL_CONSTANTS: [&str; 6] = [
  constant NAMED_PRIMITIVE_TYPES (line 65) | const NAMED_PRIMITIVE_TYPES: [&str; 27] = [
  function get_all_reserved_words (line 72) | fn get_all_reserved_words() -> HashSet<Cow<'static, str>> {

FILE: src/compile/preload_resolver.rs
  type DefaultPreloadResolver (line 41) | pub struct DefaultPreloadResolver;
  type LookupPreloadResolver (line 52) | pub struct LookupPreloadResolver(pub HashMap<PathBuf, PathBuf>);
    method insert (line 82) | pub fn insert(&mut self, key: PathBuf, value: PathBuf) -> Option<PathB...
  type PreloadResolver (line 57) | pub trait PreloadResolver {
    method resolve_preload (line 65) | fn resolve_preload(&self, path: &RPathBuf) -> Option<String>;
    method include_resource (line 72) | fn include_resource(&self, res: ResourceType) -> bool;
    method resolve_preload (line 91) | fn resolve_preload(&self, path: &RPathBuf) -> Option<String> {
    method include_resource (line 97) | fn include_resource(&self, _res: ResourceType) -> bool {
    method resolve_preload (line 108) | fn resolve_preload(&self, path: &RPathBuf) -> Option<String> {
    method include_resource (line 115) | fn include_resource(&self, res: ResourceType) -> bool {

FILE: src/compile/resource_type.rs
  type ResourceType (line 33) | pub enum ResourceType {
    method from_path (line 58) | pub fn from_path<P : AsRef<Path> + ?Sized>(path: &P) -> ResourceType {
    method from_file_extension (line 66) | pub fn from_file_extension<S : AsRef<OsStr> + ?Sized>(ext: &S) -> Reso...
    method can_have_macros (line 81) | pub fn can_have_macros(&self) -> bool {
    method is_import_allowed (line 90) | pub fn is_import_allowed(&self, import: &ImportDecl) -> bool {
    method check_import (line 102) | pub fn check_import(_pipeline: &Pipeline, import: &ImportDecl) -> Resu...
    method from (line 121) | fn from(path: &Path) -> ResourceType {
    method from (line 129) | fn from(imp: &ImportDecl) -> ResourceType {

FILE: src/compile/special_form/closure.rs
  type IRArgList (line 27) | type IRArgList = crate::ir::arglist::ordinary::ArgList;
  type IRExpr (line 28) | type IRExpr = crate::ir::expr::Expr;
  type ClosureData (line 33) | pub struct ClosureData {
    method purge_globals (line 76) | pub fn purge_globals(&mut self, table: &SymbolTable) {
    method to_gd_closure_vars (line 114) | pub fn to_gd_closure_vars(&self, table: &SymbolTable) -> Vec<String> {
    method from (line 158) | fn from(function: Function<'a, 'b>) -> ClosureData {
    method from (line 176) | fn from(class: &'a LambdaClass) -> ClosureData {
    method from (line 200) | fn from(comp: LabelsComponent<'a, 'b>) -> ClosureData {
  type Function (line 56) | pub struct Function<'a, 'b> {
  type LabelsComponent (line 68) | pub struct LabelsComponent<'a, 'b>(pub &'a [&'b LocalFnClause]);
  function new (line 147) | pub fn new(args: &'a IRArgList, body: &'b IRExpr) -> Self {
  function purge_globals (line 237) | pub fn purge_globals(vars: &mut Locals, table: &SymbolTable) {
  function closure_fn_to_gd_var (line 248) | pub fn closure_fn_to_gd_var(call: &FnCall) -> Option<String> {

FILE: src/compile/special_form/flet.rs
  type IRExpr (line 40) | type IRExpr = ir::expr::Expr;
  type IRArgList (line 41) | type IRArgList = ir::arglist::ordinary::ArgList;
  function compile_flet (line 43) | pub fn compile_flet(frame: &mut CompilerFrame<StmtBuilder>,
  function compile_flet_call (line 59) | fn compile_flet_call(frame: &mut CompilerFrame<StmtBuilder>,
  function compile_labels (line 94) | pub fn compile_labels(frame: &mut CompilerFrame<StmtBuilder>,
  type CompileLabelsRecAlgorithm (line 121) | struct CompileLabelsRecAlgorithm<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j,...
  function compile_labels_rec (line 134) | fn compile_labels_rec(&mut self) -> Result<StExpr, GDError> {
  method get_symbol_table (line 174) | fn get_symbol_table(&self) -> &SymbolTable {
  method get_symbol_table_mut (line 178) | fn get_symbol_table_mut(&mut self) -> &mut SymbolTable {
  function is_declaration_semiglobal (line 197) | pub fn is_declaration_semiglobal(args: &IRArgList, body: &IRExpr, table:...
  function all_names_are_nonlocal (line 207) | fn all_names_are_nonlocal<I, T>(mut names: I, table: &SymbolTable)

FILE: src/compile/special_form/lambda.rs
  type IRExpr (line 53) | type IRExpr = ir::expr::Expr;
  type IRArgList (line 54) | type IRArgList = ir::arglist::ordinary::ArgList;
  function compile_labels_scc (line 56) | pub fn compile_labels_scc(frame: &mut CompilerFrame<StmtBuilder>,
  function generate_scc_name (line 175) | fn generate_scc_name(original_name: &str, gen: &mut FreshNameGenerator) ...
  function generate_names_for_scc_clauses (line 180) | fn generate_names_for_scc_clauses<'a>(clauses: impl Iterator<Item=&'a Lo...
  function special_local_fn_call (line 190) | pub fn special_local_fn_call(labels_var: String, function: String, specs...
  function locally_bind_vars (line 200) | pub fn locally_bind_vars(compiler: &mut Compiler,
  function protect_closure_var_name (line 226) | fn protect_closure_var_name(gen: &mut impl NameGenerator, var: &mut Loca...
  function locally_bind_fns (line 236) | pub fn locally_bind_fns<L>(compiler: &mut Compiler,
  function copy_global_vars (line 262) | pub fn copy_global_vars(src_table: &SymbolTable, dest_table: &mut Symbol...
  function make_constructor_call (line 282) | pub fn make_constructor_call(class_name: String,
  function wrap_in_cell_if_needed (line 296) | fn wrap_in_cell_if_needed(name: &str, gd_name: &str, all_vars: &Locals, ...
  function compile_lambda_stmt (line 304) | pub fn compile_lambda_stmt(frame: &mut CompilerFrame<StmtBuilder>,
  function compile_function_ref (line 398) | pub fn compile_function_ref(compiler: &mut Compiler,
  function simple_arg_names (line 460) | pub fn simple_arg_names(count: usize) -> ArgList {

FILE: src/compile/special_form/lambda_class.rs
  function compile_lambda_class (line 40) | pub fn compile_lambda_class(frame: &mut CompilerFrame<StmtBuilder>,
  function get_all_instance_scoped_vars (line 167) | fn get_all_instance_scoped_vars(decls: &[ir::decl::ClassInnerDecl]) -> V...
  function compile_lambda_class_constructor (line 187) | fn compile_lambda_class_constructor(frame: &mut CompilerFrame<impl HasDe...

FILE: src/compile/special_form/lambda_vararg/builder.rs
  type LambdaVarargBuilder (line 32) | pub struct LambdaVarargBuilder {
    method new (line 45) | pub fn new(args_variable: String, pos: SourceOffset) -> LambdaVarargBu...
    method with_existing_args (line 53) | pub fn with_existing_args(args_variable: String, args: impl Iterator<I...
    method with_inner_builder (line 71) | pub fn with_inner_builder(&self, block: impl FnOnce(&mut LambdaVarargB...
    method declare_argument_var (line 83) | pub fn declare_argument_var(&mut self, name: String) {
    method push_error (line 90) | pub fn push_error(&mut self, message: &str) {
    method pop_argument (line 104) | pub fn pop_argument(&mut self, variable_name: &str) {
    method assign_to_var (line 118) | pub fn assign_to_var(&mut self, variable_name: &str, value: Expr) {
    method pop_rest_of_arguments_with (line 131) | pub fn pop_rest_of_arguments_with<F>(&mut self, function: F)
    method pop_rest_of_arguments (line 142) | pub fn pop_rest_of_arguments(&mut self) {
    method call_function_with_arguments (line 150) | pub fn call_function_with_arguments(&mut self, function_name: &str) {
    method if_args_is_empty (line 162) | pub fn if_args_is_empty<F1, F2>(&mut self, empty_block: F1, nonempty_b...
    method build (line 177) | pub fn build(self) -> Vec<Stmt> {

FILE: src/compile/special_form/lambda_vararg/mod.rs
  constant ARGS_VAR (line 33) | const ARGS_VAR: &str = "args";
  function generate_lambda_vararg (line 35) | pub fn generate_lambda_vararg(specs: FnSpecs, pos: SourceOffset) -> decl...
  function generate_lambda_class (line 86) | pub fn generate_lambda_class(class_name: String,
  function gdlisp_function_class (line 133) | fn gdlisp_function_class(minimalist_run: bool) -> ClassExtends {
  function compile_vararg (line 146) | fn compile_vararg(specs: FnSpecs) -> String {
  function test_lambda_vararg (line 152) | fn test_lambda_vararg() {

FILE: src/compile/special_form/let_block.rs
  type IRExpr (line 33) | type IRExpr = ir::expr::Expr;
  function compile_let (line 35) | pub fn compile_let(frame: &mut CompilerFrame<StmtBuilder>,

FILE: src/compile/special_form/mod.rs
  type IRExpr (line 45) | type IRExpr = ir::expr::Expr;
  function compile_cond_stmt (line 47) | pub fn compile_cond_stmt(frame: &mut CompilerFrame<StmtBuilder>,
  function compile_while_stmt (line 94) | pub fn compile_while_stmt(frame: &mut CompilerFrame<StmtBuilder>,
  function compile_for_stmt (line 125) | pub fn compile_for_stmt(frame: &mut CompilerFrame<StmtBuilder>,
  function assign_to_compiler (line 147) | pub fn assign_to_compiler(inst_var: String, local_var: String, pos: Sour...
  function assign_expr_to_compiler (line 153) | pub fn assign_expr_to_compiler(inst_var: String, expr: Expr) -> Stmt {

FILE: src/compile/stateful.rs
  type StExpr (line 40) | pub struct StExpr {
  type SideEffects (line 55) | pub enum SideEffects {
    method reads_state (line 166) | pub fn reads_state(&self) -> bool {
    method modifies_state (line 181) | pub fn modifies_state(&self) -> bool {
    method from (line 193) | fn from(x: AccessType) -> SideEffects {
  type NeedsResult (line 93) | pub enum NeedsResult { No, Yes }
    method from (line 102) | fn from(b: bool) -> NeedsResult {
    method or (line 110) | pub fn or(self, other: NeedsResult) -> NeedsResult {
    method and (line 115) | pub fn and(self, other: NeedsResult) -> NeedsResult {
    method into_destination (line 136) | pub fn into_destination(self,
  function from (line 96) | fn from(s: NeedsResult) -> bool {

FILE: src/compile/stmt_wrapper.rs
  type StmtWrapper (line 35) | pub trait StmtWrapper {
    method wrap_expr (line 38) | fn wrap_expr(&self, expr: Expr) -> Stmt;
    method is_vacuous (line 49) | fn is_vacuous(&self) -> bool {
    method wrap_to_builder (line 65) | fn wrap_to_builder(&self, builder: &mut StmtBuilder, expr: StExpr) {
    method wrap_to_stmt (line 76) | fn wrap_to_stmt(&self, expr: StExpr) -> Option<Stmt> {
    method wrap_expr (line 102) | fn wrap_expr(&self, expr: Expr) -> Stmt {
    method wrap_expr (line 110) | fn wrap_expr(&self, expr: Expr) -> Stmt {
    method is_vacuous (line 115) | fn is_vacuous(&self) -> bool {
    method wrap_expr (line 128) | fn wrap_expr(&self, expr: Expr) -> Stmt {
  type Return (line 89) | pub struct Return;
  type Vacuous (line 94) | pub struct Vacuous;
  type AssignToExpr (line 99) | pub struct AssignToExpr(pub Expr);
  function assign_to_var (line 123) | pub fn assign_to_var(s: String, pos: SourceOffset) -> AssignToExpr {

FILE: src/compile/symbol_table/call_magic/mod.rs
  type CallMagic (line 79) | pub enum CallMagic {
    method is_default (line 257) | pub fn is_default(&self) -> bool {
    method compile (line 266) | pub fn compile(&self,
    method can_be_called_as_const (line 557) | pub fn can_be_called_as_const(&self, arg_count: usize) -> bool {
  type Assoc (line 198) | pub enum Assoc {
  function strip_st (line 208) | fn strip_st(x: Vec<StExpr>) -> Vec<Expr> {
  function compile_default_call (line 219) | pub fn compile_default_call(call: FnCall, mut args: Vec<Expr>, pos: Sour...

FILE: src/compile/symbol_table/call_magic/table.rs
  type MagicTable (line 41) | pub struct MagicTable {
    method new (line 48) | pub fn new() -> MagicTable {
    method get (line 53) | pub fn get(&self, name: &str) -> Option<&CallMagic> {
    method set (line 59) | pub fn set(&mut self, name: String, value: CallMagic) {
    method del (line 65) | pub fn del(&mut self, name: &str) {
    method into_hashmap (line 70) | pub fn into_hashmap(self) -> HashMap<String, CallMagic> {
    method from (line 77) | fn from(values: HashMap<String, CallMagic>) -> MagicTable {

FILE: src/compile/symbol_table/function_call.rs
  type FnCall (line 44) | pub struct FnCall {
    method file_macro (line 178) | pub fn file_macro(specs: FnSpecs, scope: FnScope, function: String) ->...
    method file_constant (line 183) | pub fn file_constant(specs: FnSpecs, scope: FnScope, function: String)...
    method superglobal (line 188) | pub fn superglobal(specs: FnSpecs, scope: FnScope, function: String) -...
    method can_be_called_as_const (line 195) | pub fn can_be_called_as_const(&self) -> bool {
    method into_expr (line 210) | pub fn into_expr(self,
    method into_expr_with_magic (line 222) | pub fn into_expr_with_magic(self,
  type FnScope (line 65) | pub enum FnScope {
    method is_local (line 339) | pub fn is_local(&self) -> bool {
    method local_name (line 348) | pub fn local_name(&self) -> Option<&str> {
  type FnName (line 113) | pub enum FnName {
    method imported_constant (line 360) | pub fn imported_constant(orig_name: VarName) -> FnName {
    method on_local_var (line 365) | pub fn on_local_var(local_name: VarName) -> FnName {
    method into_imported (line 376) | pub fn into_imported(self, import_name: String) -> FnName {
    method into_imported_var (line 380) | pub fn into_imported_var(self, import: VarName) -> FnName {
    method inner_static_load (line 413) | pub fn inner_static_load(resolver: &(impl PreloadResolver + ?Sized), l...
    method update_for_inner_scope (line 446) | pub fn update_for_inner_scope(&mut self,
    method needs_inner_scope_reference (line 470) | pub fn needs_inner_scope_reference(&self) -> bool {
    method into_inner_scope (line 486) | pub fn into_inner_scope(mut self,
    method into_expr (line 500) | pub fn into_expr(self, pos: SourceOffset) -> Option<Expr> {
    method from (line 540) | fn from(var_name: VarName) -> FnName {
  type FnSpecs (line 132) | pub struct FnSpecs {
    constant EMPTY (line 238) | pub const EMPTY: FnSpecs = FnSpecs { required: 0, optional: 0, rest: N...
    method new (line 241) | pub fn new(required: usize, optional: usize, rest: Option<VarArg>) -> ...
    method has_rest (line 247) | pub fn has_rest(&self) -> bool {
    method runtime_arity (line 280) | pub fn runtime_arity(&self) -> usize {
    method min_arity (line 301) | pub fn min_arity(&self) -> usize {
    method max_arity (line 325) | pub fn max_arity(&self) -> usize {
  type OuterStaticRef (line 164) | pub enum OuterStaticRef<'a> {
  function from_ref_type (line 520) | pub fn from_ref_type(static_binding: bool, outer_ref_name: &'a str) -> S...
  function from_option_ref (line 530) | pub fn from_option_ref(outer_ref_name: Option<&'a str>) -> Self {
  method from (line 546) | fn from(specs: FnSpecs) -> Expecting {

FILE: src/compile/symbol_table/inner.rs
  type InnerSymbolTable (line 34) | pub struct InnerSymbolTable<'a> {
  function new (line 43) | pub fn new(inner_table: SymbolTable, outer_table: &'a mut SymbolTable) -...
  function with_synthetics_from (line 49) | pub fn with_synthetics_from(outer_table: &'a mut SymbolTable) -> Self {
  function cloned_from (line 56) | pub fn cloned_from(outer_table: &'a mut SymbolTable) -> Self {
  type Target (line 64) | type Target = SymbolTable;
  method deref (line 66) | fn deref(&self) -> &SymbolTable {
  method deref_mut (line 73) | fn deref_mut(&mut self) -> &mut SymbolTable {
  method drop (line 80) | fn drop(&mut self) {

FILE: src/compile/symbol_table/local_var.rs
  type LocalVar (line 42) | pub struct LocalVar {
    method read (line 191) | pub fn read(name: String) -> LocalVar {
    method rw (line 197) | pub fn rw(name: String) -> LocalVar {
    method closed_rw (line 202) | pub fn closed_rw(name: String) -> LocalVar {
    method local (line 207) | pub fn local(name: String, access_type: AccessType) -> LocalVar {
    method outer_class_ref (line 219) | pub fn outer_class_ref(name: String, access_type: AccessType) -> Local...
    method superglobal (line 232) | pub fn superglobal(name: String) -> LocalVar {
    method file_constant (line 244) | pub fn file_constant(name: String) -> LocalVar {
    method current_file (line 257) | pub fn current_file(name: String) -> LocalVar {
    method self_var (line 272) | pub fn self_var() -> LocalVar { // TODO Should this be a special case?
    method no_assign (line 279) | pub fn no_assign(mut self) -> Self {
    method with_hint (line 286) | pub fn with_hint(mut self, value_hint: ValueHint) -> Self {
    method simple_name (line 293) | pub fn simple_name(&self) -> Option<&str> {
    method set_simple_name (line 300) | pub fn set_simple_name(&mut self, name: String) {
    method is_valid_const_expr (line 330) | pub fn is_valid_const_expr(&self) -> bool {
    method expr (line 359) | pub fn expr(&self, pos: SourceOffset) -> Expr {
  type VarName (line 65) | pub enum VarName {
    method load_expr (line 378) | pub fn load_expr(filename: String, pos: SourceOffset) -> Expr {
    method local (line 383) | pub fn local(name: &str) -> VarName {
    method outer_class_ref (line 388) | pub fn outer_class_ref(name: &str) -> VarName {
    method file_constant (line 393) | pub fn file_constant(name: &str) -> VarName {
    method superglobal (line 398) | pub fn superglobal(name: &str) -> VarName {
    method imported_constant (line 403) | pub fn imported_constant(orig_name: VarName, name: &str) -> VarName {
    method current_file (line 408) | pub fn current_file(filename: &str) -> VarName {
    method to_gd (line 414) | pub fn to_gd(&self, pos: SourceOffset) -> String {
    method simple_name (line 423) | pub fn simple_name(&self) -> Option<&str> {
    method into_imported (line 444) | pub fn into_imported(self, import_name: String) -> VarName {
    method into_imported_var (line 448) | pub fn into_imported_var(self, import: VarName) -> VarName {
    method into_expr (line 496) | pub fn into_expr(self, pos: SourceOffset) -> Expr {
  type VarNameIntoExtendsError (line 101) | pub enum VarNameIntoExtendsError {
    method fmt (line 582) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type VarScope (line 124) | pub enum VarScope {
  type ValueHint (line 141) | pub enum ValueHint {
    method enumeration (line 562) | pub fn enumeration<'a>(values: impl Iterator<Item=&'a str>) -> ValueHi...
    method from_file_ext (line 570) | pub fn from_file_ext(file_extension: &OsStr) -> Option<ValueHint> {
  type ValueHintsTable (line 171) | pub trait ValueHintsTable {
    method get_value_hint (line 174) | fn get_value_hint(&self, name: &str) -> Option<&ValueHint>;
    method get_value_hint (line 182) | fn get_value_hint(&self, _name: &str) -> Option<&ValueHint> {
  type VacuousValueHintsTable (line 179) | pub struct VacuousValueHintsTable;
  type Error (line 516) | type Error = VarNameIntoExtendsError;
  method try_from (line 523) | fn try_from(var_name: VarName) -> Result<ClassExtends, VarNameIntoExtend...
  function qualified (line 612) | fn qualified(mut name: Vec<&'static str>) -> ClassExtends {
  function extends_constant (line 619) | fn extends_constant() {
  function extends_superglobal (line 627) | fn extends_superglobal() {
  function extends_imported (line 635) | fn extends_imported() {
  function cannot_extend_local (line 643) | fn cannot_extend_local() {
  function cannot_extend_subscripted (line 651) | fn cannot_extend_subscripted() {
  function cannot_extend_current_file (line 659) | fn cannot_extend_current_file() {
  function cannot_extend_null_value (line 667) | fn cannot_extend_null_value() {
  function from_file_ext_test (line 675) | fn from_file_ext_test() {

FILE: src/compile/symbol_table/mod.rs
  type SymbolTable (line 49) | pub struct SymbolTable {
    method new (line 94) | pub fn new() -> SymbolTable {
    method with_synthetics_from (line 102) | pub fn with_synthetics_from(table: &SymbolTable) -> SymbolTable {
    method dump_synthetics_to (line 110) | pub fn dump_synthetics_to(&self, destination_table: &mut SymbolTable) {
    method get_var (line 126) | pub fn get_var(&self, name: &str) -> Option<&LocalVar> {
    method get_var_by_gd_name (line 133) | pub fn get_var_by_gd_name(&self, gd_name: &str) -> Option<&LocalVar> {
    method get_fn_by_gd_name (line 140) | pub fn get_fn_by_gd_name(&self, gd_name: &str) -> Option<(&FnCall, &Ca...
    method set_var (line 146) | pub fn set_var(&mut self, name: String, value: LocalVar) -> Option<Loc...
    method del_var (line 162) | pub fn del_var(&mut self, name: &str) {
    method add_synthetic_var (line 174) | pub fn add_synthetic_var(&mut self, name: String, is_local: bool) {
    method remove_synthetic_var (line 180) | pub fn remove_synthetic_var(&mut self, name: &str) {
    method clear_synthetic_locals (line 185) | pub fn clear_synthetic_locals(&mut self) {
    method get_fn (line 191) | pub fn get_fn(&self, name: &str) -> Option<(&FnCall, &CallMagic)> {
    method set_fn (line 199) | pub fn set_fn(&mut self, name: String, value: FnCall, magic: CallMagic) {
    method del_fn (line 210) | pub fn del_fn(&mut self, name: &str) {
    method add_synthetic_fn (line 220) | pub fn add_synthetic_fn(&mut self, name: String) {
    method remove_synthetic_fn (line 226) | pub fn remove_synthetic_fn(&mut self, name: &str) {
    method vars (line 231) | pub fn vars(&self) -> impl Iterator<Item=(&str, &LocalVar)> {
    method fns (line 236) | pub fn fns(&self) -> impl Iterator<Item=(&str, &FnCall, &CallMagic)> {
    method fns_mut (line 245) | pub fn fns_mut(&mut self) -> impl Iterator<Item=(&str, &mut FnCall, &m...
    method keys (line 254) | pub fn keys(&self) -> impl Iterator<Item=(Namespace, &str)> {
    method into_keys (line 263) | pub fn into_keys(self) -> impl Iterator<Item=Id> {
    method assign_from (line 273) | pub fn assign_from(&mut self, other: &SymbolTable) {
    method has_var_with_gd_name (line 284) | pub fn has_var_with_gd_name(&self, name: &str) -> bool {
    method has_fn_with_gd_name (line 291) | pub fn has_fn_with_gd_name(&self, name: &str) -> bool {
  type ClassTablePair (line 83) | pub struct ClassTablePair<'a, 'b> {
  type HasSymbolTable (line 300) | pub trait HasSymbolTable {
    method get_symbol_table (line 303) | fn get_symbol_table(&self) -> &SymbolTable;
    method get_symbol_table_mut (line 306) | fn get_symbol_table_mut(&mut self) -> &mut SymbolTable;
    method with_local_var (line 312) | fn with_local_var<B, F>(&mut self,
    method with_local_vars (line 330) | fn with_local_vars<B>(&mut self,
    method with_local_fn (line 346) | fn with_local_fn<B>(&mut self,
    method with_local_fns (line 364) | fn with_local_fns<B>(&mut self,
    method get_symbol_table (line 380) | fn get_symbol_table(&self) -> &SymbolTable {
    method get_symbol_table_mut (line 384) | fn get_symbol_table_mut(&mut self) -> &mut SymbolTable {
  method get_value_hint (line 394) | fn get_value_hint(&self, name: &str) -> Option<&ValueHint> {
  function into_table (line 403) | pub fn into_table(self, is_static: bool) -> &'a mut SymbolTable {
  function from_var_name (line 421) | fn from_var_name(e: &VarName) -> &str {
  function test_vars (line 426) | fn test_vars() {
  function test_iter_vars (line 454) | fn test_iter_vars() {
  function sample_fn (line 464) | fn sample_fn() -> FnCall {
  function test_fns (line 469) | fn test_fns() {
  function test_iter_fns (line 488) | fn test_iter_fns() {
  function test_synthetic_vars (line 500) | fn test_synthetic_vars() {
  function test_synthetic_fns (line 510) | fn test_synthetic_fns() {

FILE: src/gdscript/arglist.rs
  type ArgList (line 37) | pub struct ArgList {
    method empty (line 47) | pub fn empty() -> ArgList {
    method required (line 52) | pub fn required(args: Vec<String>) -> ArgList {
    method optional (line 71) | pub fn optional(mut self, args: impl IntoIterator<Item=(String, Expr)>...
    method is_empty (line 77) | pub fn is_empty(&self) -> bool {
    method prepend_required (line 83) | pub fn prepend_required(&mut self, required: impl Iterator<Item=String...
    method optionalize_all (line 93) | pub fn optionalize_all(&mut self, default_value: &Expr) {
    method all_args_iter (line 100) | pub fn all_args_iter(&self) -> impl Iterator<Item=&str> {
    method to_gd (line 107) | pub fn to_gd(&self) -> String {
  function null (line 127) | fn null() -> Expr {
  function empty_arglist_to_gd_test (line 132) | fn empty_arglist_to_gd_test() {
  function required_arglist_to_gd_test (line 137) | fn required_arglist_to_gd_test() {
  function optional_arglist_to_gd_test (line 144) | fn optional_arglist_to_gd_test() {
  function full_arglist_to_gd_test (line 150) | fn full_arglist_to_gd_test() {
  function optional_arglist_custom_expr_to_gd_test (line 158) | fn optional_arglist_custom_expr_to_gd_test() {
  function prepend_required_test (line 164) | fn prepend_required_test() {
  function all_args_iter_test (line 171) | fn all_args_iter_test() {

FILE: src/gdscript/class_extends.rs
  type ClassExtends (line 25) | pub enum ClassExtends {
    method attribute (line 39) | pub fn attribute(self, attr: impl Into<String>) -> ClassExtends {
    method to_gd (line 45) | pub fn to_gd(&self) -> String {
  function test_simple_identifier (line 60) | fn test_simple_identifier() {
  function test_string_literal (line 66) | fn test_string_literal() {
  function test_string_literal_escaped (line 72) | fn test_string_literal_escaped() {
  function test_qualified_identifier (line 78) | fn test_qualified_identifier() {
  function test_qualified_path (line 84) | fn test_qualified_path() {

FILE: src/gdscript/decl.rs
  type DeclF (line 38) | pub enum DeclF {
  type Decl (line 51) | pub struct Decl {
    method new (line 154) | pub fn new(value: DeclF, pos: SourceOffset) -> Decl {
    method name (line 161) | pub fn name(&self) -> Option<&str> {
    method write_gd (line 184) | pub fn write_gd<W : fmt::Write>(&self, w: &mut W, ind: u32) -> Result<...
    method to_gd (line 273) | pub fn to_gd(&self, ind: u32) -> String {
  type ClassDecl (line 57) | pub struct ClassDecl {
  type TopLevelClass (line 69) | pub struct TopLevelClass {
    method to_gd (line 297) | pub fn to_gd(&self) -> String {
  type VarDecl (line 80) | pub struct VarDecl {
    method new (line 323) | pub fn new(name: String, value: Option<Expr>) -> VarDecl {
    method simple (line 335) | pub fn simple(name: String) -> VarDecl {
    method with_export (line 340) | pub fn with_export(mut self, export: Option<Export>) -> VarDecl {
    method onready (line 346) | pub fn onready(mut self) -> VarDecl {
    method setget (line 352) | pub fn setget(mut self, setget: Setget) -> VarDecl {
  type FnDecl (line 89) | pub struct FnDecl {
  type InitFnDecl (line 96) | pub struct InitFnDecl {
  type EnumDecl (line 103) | pub struct EnumDecl {
  type Export (line 114) | pub struct Export {
  type Static (line 121) | pub enum Static {
    method from (line 388) | fn from(b: bool) -> Static {
  type Onready (line 128) | pub enum Onready {
    method from (line 394) | fn from(b: bool) -> Onready {
  type Setget (line 135) | pub struct Setget {
    method to_gd (line 364) | pub fn to_gd(&self) -> String {
  function empty_class_body (line 140) | fn empty_class_body(pos: SourceOffset) -> Decl {
  type Item (line 282) | type Item = DeclF;
  method get_source (line 284) | fn get_source(&self) -> SourceOffset {
  method get_value (line 288) | fn get_value(&self) -> &DeclF {
  function from (line 376) | fn from(s: Static) -> bool {
  function from (line 382) | fn from(r: Onready) -> bool {
  function e (line 405) | fn e(expr: ExprF) -> Expr {
  function d (line 409) | fn d(decl: DeclF) -> Decl {
  function var (line 415) | fn var(export: Option<Export>, onready: Onready, name: String, value: Op...
  function var_and_const (line 420) | fn var_and_const() {
  function exported_var (line 430) | fn exported_var() {
  function setget_var (line 447) | fn setget_var() {
  function signal (line 470) | fn signal() {
  function functions (line 476) | fn functions() {
  function init_functions (line 516) | fn init_functions() {
  function classes (line 549) | fn classes() {
  function enums (line 611) | fn enums() {
  function decl_names (line 638) | fn decl_names() {

FILE: src/gdscript/expr.rs
  constant PRECEDENCE_LOWEST (line 35) | pub const PRECEDENCE_LOWEST: i32 = -99;
  constant PRECEDENCE_SUBSCRIPT (line 36) | pub const PRECEDENCE_SUBSCRIPT: i32 = 21;
  constant PRECEDENCE_ATTRIBUTE (line 37) | pub const PRECEDENCE_ATTRIBUTE: i32 = 20;
  constant PRECEDENCE_CALL (line 38) | pub const PRECEDENCE_CALL: i32 = 19;
  type ExprF (line 42) | pub enum ExprF {
    method from (line 297) | fn from(x: T) -> ExprF {
    method from (line 303) | fn from(x: TernaryIf) -> ExprF {
  type Expr (line 66) | pub struct Expr {
    method new (line 90) | pub fn new(value: ExprF, pos: SourceOffset) -> Expr {
    method null (line 95) | pub fn null(pos: SourceOffset) -> Expr {
    method self_var (line 100) | pub fn self_var(pos: SourceOffset) -> Expr {
    method str_lit (line 105) | pub fn str_lit(a: &str, pos: SourceOffset) -> Expr {
    method var (line 111) | pub fn var(a: &str, pos: SourceOffset) -> Expr {
    method attribute (line 117) | pub fn attribute(self, attr: impl Into<String>, pos: SourceOffset) -> ...
    method subscript (line 122) | pub fn subscript(self, rhs: Expr, pos: SourceOffset) -> Expr {
    method unary (line 127) | pub fn unary(self, op: UnaryOp, pos: SourceOffset) -> Expr {
    method binary (line 132) | pub fn binary(self, op: BinaryOp, rhs: Expr, pos: SourceOffset) -> Expr {
    method call (line 137) | pub fn call(lhs: Option<Expr>, name: &str, args: Vec<Expr>, pos: Sourc...
    method simple_call (line 143) | pub fn simple_call(name: &str, args: Vec<Expr>, pos: SourceOffset) -> ...
    method super_call (line 148) | pub fn super_call(name: &str, args: Vec<Expr>, pos: SourceOffset) -> E...
    method yield_expr (line 157) | pub fn yield_expr(args: Option<(Expr, Expr)>, pos: SourceOffset) -> Ex...
    method assert_expr (line 168) | pub fn assert_expr(cond: Expr, message: Option<Expr>, pos: SourceOffse...
    method preload_expr (line 177) | pub fn preload_expr(arg: String, pos: SourceOffset) -> Expr {
    method from_value (line 182) | pub fn from_value<T>(value: T, pos: SourceOffset) -> Expr
    method to_gd_prec (line 192) | pub fn to_gd_prec(&self, prec: i32) -> String {
    method to_gd (line 276) | pub fn to_gd(&self) -> String {
  type TernaryIf (line 73) | pub struct TernaryIf {
  function maybe_parens (line 79) | fn maybe_parens(cond: bool, inner: String) -> String {
  type Item (line 283) | type Item = ExprF;
  method get_source (line 285) | fn get_source(&self) -> SourceOffset {
  method get_value (line 289) | fn get_value(&self) -> &ExprF {
  function e (line 312) | fn e(expr: ExprF) -> Expr {
  function basic_expr_types (line 317) | fn basic_expr_types() {
  function call_exprs (line 345) | fn call_exprs() {
  function unary (line 373) | fn unary(op: UnaryOp, expr: &Expr) -> Expr {
  function binary (line 377) | fn binary(a: &Expr, op: BinaryOp, b: &Expr) -> Expr {
  function unary_ops (line 382) | fn unary_ops() {
  function binary_ops (line 390) | fn binary_ops() {
  function ternary_op (line 417) | fn ternary_op() {
  function operator_precedence (line 425) | fn operator_precedence() {
  function ternary_if_precedence_1 (line 438) | fn ternary_if_precedence_1() {
  function ternary_if_precedence_2 (line 460) | fn ternary_if_precedence_2() {
  function arrays (line 511) | fn arrays() {
  function dictionaries (line 519) | fn dictionaries() {

FILE: src/gdscript/expr_wrapper.rs
  function int (line 26) | pub fn int(expr: Expr) -> Expr {
  function float (line 37) | pub fn float(expr: Expr) -> Expr {
  function int_test (line 52) | fn int_test() {
  function float_test (line 60) | fn float_test() {

FILE: src/gdscript/inner_class.rs
  constant OUTER_REFERENCE_NAME (line 49) | pub const OUTER_REFERENCE_NAME: &str = "__gdlisp_outer_class";
  function add_outer_class_ref_named (line 58) | pub fn add_outer_class_ref_named(inner_class: &mut decl::ClassDecl, reso...
  function get_current_filename (line 70) | pub fn get_current_filename<L, R>(current_file: &L, resolver: &R) -> Opt...
  type NeedsOuterClassRef (line 84) | pub trait NeedsOuterClassRef {
    method needs_outer_class_ref (line 88) | fn needs_outer_class_ref(&self, table: &SymbolTable) -> bool;
    method needs_outer_class_ref (line 109) | fn needs_outer_class_ref(&self, table: &SymbolTable) -> bool {
    method needs_outer_class_ref (line 121) | fn needs_outer_class_ref(&self, table: &SymbolTable) -> bool {
    method needs_outer_class_ref (line 127) | fn needs_outer_class_ref(&self, table: &SymbolTable) -> bool {
    method needs_outer_class_ref (line 135) | fn needs_outer_class_ref(&self, table: &SymbolTable) -> bool {
    method needs_outer_class_ref (line 143) | fn needs_outer_class_ref(&self, table: &SymbolTable) -> bool {
  function check_dependencies_for_outer_class_ref (line 91) | fn check_dependencies_for_outer_class_ref(deps: impl Iterator<Item=Id>, ...

FILE: src/gdscript/library/cell.rs
  constant CELL_CLASS (line 63) | pub const CELL_CLASS: &str = "Cell";
  constant CELL_CONTENTS (line 66) | pub const CELL_CONTENTS: &str = "contents";
  function cell_class (line 69) | pub fn cell_class(pos: SourceOffset) -> Expr {
  function construct_cell (line 75) | pub fn construct_cell(expr: Expr) -> Expr {
  function wrap_var_in_cell (line 82) | pub fn wrap_var_in_cell(stmt_builder: &mut StmtBuilder, arg: &str, pos: ...

FILE: src/gdscript/library/class_loader.rs
  constant CLASS_NAME_BLACKLIST (line 33) | const CLASS_NAME_BLACKLIST: phf::Set<&'static str> = phf_set! {
  constant PATCHED_CLASS_NAMES (line 41) | const PATCHED_CLASS_NAMES: phf::Map<&'static str, &'static str> = phf_ma...
  function get_all_non_singleton_classes (line 49) | pub fn get_all_non_singleton_classes(native: &NativeClasses) -> Vec<&Cla...
  function get_all_singleton_classes (line 58) | pub fn get_all_singleton_classes(native: &NativeClasses) -> Vec<&Class> {
  function get_non_singleton_declarations (line 67) | pub fn get_non_singleton_declarations(native: &NativeClasses) -> impl It...
  function get_singleton_declarations (line 73) | pub fn get_singleton_declarations(native: &NativeClasses) -> Vec<Declare...
  function get_singleton_class_var_declarations (line 83) | pub fn get_singleton_class_var_declarations(native: &NativeClasses, pos:...
  function type_declaration_for_class (line 105) | fn type_declaration_for_class(class: &Class, declare_type: DeclareType) ...
  function value_declaration_for_singleton (line 115) | fn value_declaration_for_singleton(class: &Class, declare_type: DeclareT...
  function backing_class_name_of (line 125) | fn backing_class_name_of(class: &Class) -> String {
  function native_types_dictionary_literal (line 141) | pub fn native_types_dictionary_literal(native: &NativeClasses, pos: Sour...
  function build_dict (line 171) | fn build_dict(terms: impl DoubleEndedIterator<Item=(Expr, Expr)>, pos: S...
  function native_types_dictionary_initializer (line 175) | pub fn native_types_dictionary_initializer(native: &NativeClasses, pos: ...
  function test_non_singleton_classes (line 195) | fn test_non_singleton_classes() {
  function test_singleton_classes (line 211) | fn test_singleton_classes() {

FILE: src/gdscript/library/constant_loader.rs
  constant ENUM_GROUPINGS_BY_PREFIX (line 30) | const ENUM_GROUPINGS_BY_PREFIX: phf::Map<&'static str, &'static str> = p...
  constant ENUM_BLACKLIST (line 50) | const ENUM_BLACKLIST: phf::Set<&'static str> = phf_set! { "SPKEY" };
  constant ENUM_CUSTOM_NAMES (line 53) | const ENUM_CUSTOM_NAMES: phf::Map<&'static str, &'static str> = phf_map! {
  type ConstantEnum (line 71) | pub struct ConstantEnum {
  type EnumGrouping (line 78) | enum EnumGrouping {
  function get_all_constants (line 85) | pub fn get_all_constants(classes: &NativeClasses) -> impl Iterator<Item=...
  function get_all_constant_enums (line 90) | pub fn get_all_constant_enums(classes: &NativeClasses, pos: SourceOffset...
  function get_all_constant_enums_with_leftovers (line 94) | fn get_all_constant_enums_with_leftovers(classes: &NativeClasses, pos: S...
  function identify_enum_grouping (line 135) | fn identify_enum_grouping(table: &PrefixMatcher<'_>, constant_name: &str...
  method from (line 154) | fn from(constant_enum: ConstantEnum) -> EnumDecl {
  function all_constants_classified_test (line 177) | fn all_constants_classified_test() {

FILE: src/gdscript/library/gdnative/api_type.rs
  type ApiType (line 26) | pub enum ApiType {
  function serialize_api_type_test (line 40) | fn serialize_api_type_test() {
  function deserialize_api_type_test (line 48) | fn deserialize_api_type_test() {

FILE: src/gdscript/library/gdnative/argument.rs
  type Argument (line 21) | pub struct Argument {
  function serialize_roundtrip_argument_test (line 35) | fn serialize_roundtrip_argument_test() {
  function deserialize_argument_test (line 47) | fn deserialize_argument_test() {

FILE: src/gdscript/library/gdnative/class.rs
  type Class (line 29) | pub struct Class {
  constant SAMPLE_CLASS_JSON (line 52) | const SAMPLE_CLASS_JSON: &str = r#"{
  function deserialize_class_test (line 113) | fn deserialize_class_test() {

FILE: src/gdscript/library/gdnative/gdnative_enum.rs
  type Enum (line 23) | pub struct Enum {
  function deserialize_enum_test (line 34) | fn deserialize_enum_test() {

FILE: src/gdscript/library/gdnative/method.rs
  type Method (line 23) | pub struct Method {
  function deserialize_method_test (line 42) | fn deserialize_method_test() {

FILE: src/gdscript/library/gdnative/mod.rs
  constant GLOBAL_CONSTANTS_CLASS (line 37) | pub const GLOBAL_CONSTANTS_CLASS: &str = "GlobalConstants";
  type NativeClasses (line 40) | pub struct NativeClasses {
    method get_api_from_godot (line 46) | pub fn get_api_from_godot() -> io::Result<NativeClasses> {
    method len (line 56) | pub fn len(&self) -> usize {
    method is_empty (line 60) | pub fn is_empty(&self) -> bool {
    method get (line 64) | pub fn get(&self, class_name: &str) -> Option<&Class> {
    method get_global_constants (line 68) | pub fn get_global_constants(&self) -> &Class {
    method values (line 72) | pub fn values(&self) -> impl Iterator<Item=&Class> {
  function test_get_api_from_godot (line 83) | fn test_get_api_from_godot() {

FILE: src/gdscript/library/gdnative/property.rs
  type Property (line 21) | pub struct Property {
  function deserialize_property_test (line 36) | fn deserialize_property_test() {

FILE: src/gdscript/library/gdnative/signal.rs
  type Signal (line 23) | pub struct Signal {
  function deserialize_signal_test (line 34) | fn deserialize_signal_test() {

FILE: src/gdscript/library/magic.rs
  function bind_magic (line 48) | pub fn bind_magic(table: &mut MagicTable) {
  function standard_magic_table (line 200) | pub fn standard_magic_table() -> MagicTable {

FILE: src/gdscript/library/mod.rs
  constant GDLISP_NAME (line 53) | pub const GDLISP_NAME: &str = "GDLisp";
  constant CONSTRUCTOR_NAME (line 56) | pub const CONSTRUCTOR_NAME: &str = "_init";
  constant READY_NAME (line 60) | pub const READY_NAME: &str = "_ready";
  constant REFERENCE_NAME (line 63) | pub const REFERENCE_NAME: &str = "Reference";
  function gdlisp_root (line 66) | pub fn gdlisp_root(pos: SourceOffset) -> Expr {
  function gdlisp_root_var_name (line 71) | pub fn gdlisp_root_var_name() -> VarName {
  function on_gdlisp_root (line 76) | pub fn on_gdlisp_root(name: String, pos: SourceOffset) -> Expr {
  function construct_list (line 82) | pub fn construct_list(vec: Vec<Expr>, pos: SourceOffset) -> Expr {
  function gdlisp_project_config (line 89) | pub fn gdlisp_project_config(godot_version: VersionInfo) -> ProjectConfig {
  function get_stdlib (line 97) | fn get_stdlib() -> StdlibUnit {
  function load_stdlib_to_file (line 104) | pub fn load_stdlib_to_file() -> StdlibUnit {
  function load_stdlib_file (line 114) | fn load_stdlib_file(pipeline: &mut Pipeline) -> &TranslationUnit {
  function ensure_stdlib_loaded (line 131) | pub fn ensure_stdlib_loaded() {
  function bind_builtins (line 149) | pub fn bind_builtins(table: &mut SymbolTable, minimalist: bool) {
  function bind_builtins_unchecked (line 159) | fn bind_builtins_unchecked(table: &mut SymbolTable, unit: Option<&Stdlib...
  function all_builtin_names (line 193) | pub fn all_builtin_names(minimalist: bool) -> HashSet<Id> {
  function bind_builtin_macros (line 210) | pub fn bind_builtin_macros(macros: &mut HashMap<Id, MacroData>,

FILE: src/gdscript/literal.rs
  type Literal (line 38) | pub enum Literal {
    method to_gd (line 66) | pub fn to_gd(&self) -> String {
    method from (line 87) | fn from(x: i32) -> Literal {
    method from (line 93) | fn from(x: OrderedFloat<f32>) -> Literal {
    method from (line 99) | fn from(x: String) -> Literal {
    method from (line 105) | fn from(x: &'a str) -> Literal {
    method from (line 111) | fn from(x: bool) -> Literal {
    type Error (line 117) | type Error = IRToExprLiteralError;
    method try_from (line 119) | fn try_from(value: IRLiteral) -> Result<Literal, Self::Error> {
  type LiteralFloat (line 52) | pub struct LiteralFloat(pub f32);
    method fmt (line 155) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type IRToExprLiteralError (line 60) | pub struct IRToExprLiteralError;
  method eq (line 136) | fn eq(&self, other: &Self) -> bool {
  type Target (line 145) | type Target = f32;
  method deref (line 147) | fn deref(&self) -> &f32 {
  function literal_test (line 166) | fn literal_test() {
  function string_test (line 174) | fn string_test() {
  function node_path_test (line 180) | fn node_path_test() {
  function node_path_literal_test (line 187) | fn node_path_literal_test() {

FILE: src/gdscript/metadata.rs
  constant PREFIX (line 39) | pub const PREFIX: &str = "__gdlisp";
  constant CONS_META (line 43) | pub const CONS_META: &str = "__gdlisp_Primitive_Cons";
  constant SYMBOL_META (line 47) | pub const SYMBOL_META: &str = "__gdlisp_Primitive_Symbol";
  constant REPL_FUNCTION_NAME (line 51) | pub const REPL_FUNCTION_NAME: &str = "__gdlisp_Repl_runner";
  constant SIGNAL_META (line 55) | pub const SIGNAL_META: &str = "__gdlisp_signals";
  function symbol_macro (line 59) | pub fn symbol_macro(name: &str) -> String {
  function lazy (line 69) | pub fn lazy(name: &str) -> String {
  type MetadataCompiler (line 77) | pub struct MetadataCompiler {
    method new (line 85) | pub fn new(expr: Expr) -> MetadataCompiler {
    method get_pos (line 89) | fn get_pos(&self) -> SourceOffset {
    method get_meta (line 94) | pub fn get_meta(&self, meta_name: &str) -> Expr {
    method set_meta (line 100) | pub fn set_meta(&self, meta_name: &str, value: Expr) -> Expr {
    method has_meta (line 106) | pub fn has_meta(&self, meta_name: &str) -> Expr {
    method remove_meta (line 112) | pub fn remove_meta(&self, meta_name: &str) -> Expr {
  function naming_test (line 125) | fn naming_test() {
  function compiler_test (line 131) | fn compiler_test() {
  function compiler_offset_test (line 145) | fn compiler_offset_test() {

FILE: src/gdscript/mod.rs
  function indent (line 49) | pub fn indent<W: fmt::Write>(w: &mut W, ind: u32) -> Result<(), fmt::Err...
  function is_valid_identifier (line 58) | pub fn is_valid_identifier(s: &str) -> bool {
  function is_valid_node_path (line 74) | pub fn is_valid_node_path(s: &str) -> bool {
  function do_indent (line 82) | fn do_indent(ind: u32) -> String {
  function test_indent (line 89) | fn test_indent() {
  function test_identifier (line 98) | fn test_identifier() {
  function test_path (line 119) | fn test_path() {

FILE: src/gdscript/op.rs
  type UnaryOp (line 24) | pub enum UnaryOp {
  type BinaryOp (line 30) | pub enum BinaryOp {
  type AssignOp (line 37) | pub enum AssignOp {
  type TernaryOp (line 47) | pub struct TernaryOp;
  type OperatorInfo (line 51) | pub struct OperatorInfo {
  type Padding (line 73) | pub enum Padding {
  function info (line 86) | fn info(prec: i32, name: &'static str, padding: Padding) -> OperatorInfo {
  type OperatorHasInfo (line 93) | pub trait OperatorHasInfo {
    method op_info (line 95) | fn op_info(&self) -> OperatorInfo;
    method op_info (line 99) | fn op_info(&self) -> OperatorInfo {
    method op_info (line 109) | fn op_info(&self) -> OperatorInfo {
    method op_info (line 137) | fn op_info(&self) -> OperatorInfo {
    method op_info (line 155) | fn op_info(&self) -> OperatorInfo {

FILE: src/gdscript/pattern.rs
  type Pattern (line 28) | pub enum Pattern {
    method to_gd (line 48) | pub fn to_gd(&self) -> String {
  type Wildcard (line 40) | pub enum Wildcard {
  function from (line 74) | fn from(w: Wildcard) -> bool {
  function atomic_patterns (line 84) | fn atomic_patterns() {
  function compound_patterns (line 92) | fn compound_patterns() {

FILE: src/gdscript/spacing.rs
  type SpacedDeclPrinter (line 27) | pub struct SpacedDeclPrinter {
    method new (line 36) | pub fn new() -> Self {
    method with_spacing (line 42) | pub fn with_spacing(mut self, spacing: u32) -> Self {
    method with_indentation (line 49) | pub fn with_indentation(mut self, indentation: u32) -> Self {
    method write_gd (line 56) | pub fn write_gd<'a, W: Write, I: Iterator<Item=&'a Decl>>(&self, w: &m...
  function group_predicate (line 80) | fn group_predicate(a: &Decl, b: &Decl) -> bool {
  function write_newlines (line 92) | fn write_newlines(w: &mut impl Write, count: u32) -> Result<(), fmt::Err...
  method default (line 99) | fn default() -> Self {

FILE: src/gdscript/stmt.rs
  type StmtF (line 35) | pub enum StmtF {
  type Stmt (line 59) | pub struct Stmt {
    method new (line 146) | pub fn new(value: StmtF, pos: SourceOffset) -> Stmt {
    method expr (line 151) | pub fn expr(expr: Expr) -> Stmt {
    method return_stmt (line 157) | pub fn return_stmt(expr: Expr, pos: SourceOffset) -> Stmt {
    method simple_assign (line 162) | pub fn simple_assign(lhs: Expr, rhs: Expr, pos: SourceOffset) -> Stmt {
    method var_decl (line 167) | pub fn var_decl(var_name: String, value: Expr, pos: SourceOffset) -> S...
    method break_stmt (line 172) | pub fn break_stmt(pos: SourceOffset) -> Stmt {
    method continue_stmt (line 177) | pub fn continue_stmt(pos: SourceOffset) -> Stmt {
    method pass_stmt (line 182) | pub fn pass_stmt(pos: SourceOffset) -> Stmt {
    method write_gd (line 196) | pub fn write_gd<W : fmt::Write>(&self, w: &mut W, ind: u32) -> Result<...
    method write_gd_stmts (line 268) | pub fn write_gd_stmts<'a, W, I>(iter: I, w: &mut W, ind: u32) -> Resul...
    method to_gd (line 289) | pub fn to_gd(&self, ind: u32) -> String {
  type IfStmt (line 66) | pub struct IfStmt {
  type ForLoop (line 74) | pub struct ForLoop {
  type WhileLoop (line 82) | pub struct WhileLoop {
  function if_then (line 88) | pub fn if_then(cond: Expr, true_branch: Vec<Stmt>, pos: SourceOffset) ->...
  function if_else (line 101) | pub fn if_else(cond: Expr, true_branch: Vec<Stmt>, false_branch: Vec<Stm...
  function if_branches (line 124) | pub fn if_branches(cases: Vec<(Expr, Vec<Stmt>)>, default: Vec<Stmt>, po...
  type Item (line 298) | type Item = StmtF;
  method get_source (line 300) | fn get_source(&self) -> SourceOffset {
  method get_value (line 304) | fn get_value(&self) -> &StmtF {
  function assign (line 317) | fn assign(a: &Expr, op: AssignOp, b: &Expr) -> Stmt {
  function e (line 321) | fn e(expr: ExprF) -> Expr {
  function s (line 325) | fn s(stmt: StmtF) -> Stmt {
  function expr_stmt (line 330) | fn expr_stmt() {
  function basic_indent (line 336) | fn basic_indent() {
  function simple_stmts (line 343) | fn simple_stmts() {
  function if_stmt (line 350) | fn if_stmt() {
  function nested_if (line 413) | fn nested_if() {
  function for_loop (line 437) | fn for_loop() {
  function while_loop (line 458) | fn while_loop() {
  function match_stmt (line 477) | fn match_stmt() {
  function assign_ops (line 499) | fn assign_ops() {

FILE: src/graph/mod.rs
  type Graph (line 48) | pub struct Graph<T> {
  function from_edges (line 57) | pub fn from_edges<I>(iter: I) -> Graph<T>
  function from_nodes (line 78) | pub fn from_nodes<I>(iter: I) -> Graph<T>
  function new (line 84) | pub fn new() -> Graph<T> {
  function nodes (line 90) | pub fn nodes(&self) -> impl Iterator<Item=&T> {
  function get_node (line 97) | pub fn get_node<U>(&self, x: &U) -> Option<&T> where U : Borrow<T> {
  function has_node (line 102) | pub fn has_node<U>(&self, x: &U) -> bool where U : Borrow<T> {
  function all_edges (line 108) | pub fn all_edges(&self) -> impl Iterator<Item=(&T, &T)> {
  function outgoing_edges (line 114) | pub fn outgoing_edges(&self, node: impl Borrow<T>) -> Option<&Vec<T>> {
  function add_node (line 120) | pub fn add_node(&mut self, node: T) {
  function add_edge (line 126) | pub fn add_edge(&mut self, x: T, y: T) {
  function add_edge_no_dup (line 134) | pub fn add_edge_no_dup(&mut self, x: T, y: T) {
  function has_edge (line 141) | pub fn has_edge<U, V>(&self, x: &U, y: &V) -> bool where U : Borrow<T>, ...
  function remove_edge (line 150) | pub fn remove_edge<U, V>(&mut self, x: &U, y: &V) where U : Borrow<T>, V...
  function node_count (line 159) | pub fn node_count(&self) -> usize {
  function transpose (line 166) | pub fn transpose(&self) -> Graph<T>
  method default (line 179) | fn default() -> Self {

FILE: src/graph/tarjan.rs
  type SCC (line 34) | pub struct SCC<'a, T>(pub HashSet<&'a T>);
  type SCCSummary (line 38) | pub struct SCCSummary<'a, T> {
  type Algorithm (line 43) | struct Algorithm<'a, T> {
  method eq (line 54) | fn eq(&self, other: &Self) -> bool {
  method default (line 60) | fn default() -> Self {
  function get_scc_by_id (line 76) | pub fn get_scc_by_id(&self, id: usize) -> Option<&SCC<'a, T>> {
  function get_scc_id (line 81) | pub fn get_scc_id(&self, node: &'a T) -> Option<usize> {
  function get_scc (line 86) | pub fn get_scc(&self, node: &'a T) -> Option<&SCC<'a, T>> {
  function is_in_same (line 93) | pub fn is_in_same(&self, a: &'a T, b: &'a T) -> bool {
  function count (line 104) | pub fn count(&self) -> usize {
  function new (line 113) | fn new(graph: &'a Graph<T>) -> Algorithm<'a, T> {
  function strongconnect (line 125) | fn strongconnect(&mut self, v: &'a T) {
  function from (line 159) | fn from(alg: Algorithm<'a, T>) -> SCCSummary<'a, T> {
  function find_scc (line 173) | pub fn find_scc<T>(graph: &Graph<T>) -> SCCSummary<'_, T>
  function build_scc_graph (line 193) | pub fn build_scc_graph<'a, 'b, T>(graph: &'a Graph<T>, summary: &'b SCCS...
  function scc_test_isolated (line 211) | fn scc_test_isolated() {
  function scc_test_path (line 223) | fn scc_test_path() {
  function scc_test_cycle_rhs (line 235) | fn scc_test_cycle_rhs() {
  function scc_test_cycle_lhs (line 247) | fn scc_test_cycle_lhs() {
  function scc_test_one_big_cycle (line 259) | fn scc_test_one_big_cycle() {
  function scc_test_two_connected_cycles (line 266) | fn scc_test_two_connected_cycles() {

FILE: src/graph/top_sort.rs
  type CycleInTopSortError (line 26) | pub struct CycleInTopSortError {}
  function top_sort (line 36) | pub fn top_sort<T>(graph: &Graph<T>) -> Result<Vec<&T>, CycleInTopSortEr...
  function test_top_sort_1 (line 65) | fn test_top_sort_1() {
  function test_top_sort_2 (line 73) | fn test_top_sort_2() {
  function test_top_sort_3 (line 81) | fn test_top_sort_3() {
  function test_top_sort_4 (line 90) | fn test_top_sort_4() {

FILE: src/ir/access_type.rs
  type AccessType (line 85) | pub enum AccessType {
    method closed (line 126) | pub fn closed(&self) -> AccessType {
    method requires_cell (line 156) | pub fn requires_cell(&self) -> bool {
    method is_written_to (line 163) | pub fn is_written_to(&self) -> bool {
  method join (line 173) | fn join(self, b: AccessType) -> AccessType {
  method meet (line 194) | fn meet(self, b: AccessType) -> AccessType {

FILE: src/ir/arglist/constructor.rs
  type ConstructorArgList (line 40) | pub struct ConstructorArgList {
    method into_gd_arglist (line 55) | pub fn into_gd_arglist(self, gen: &mut impl NameGenerator) -> (GDArgLi...
    method has_any_instance_fields (line 64) | pub fn has_any_instance_fields(&self) -> bool {
    method iter_vars (line 71) | pub fn iter_vars(&self) -> impl Iterator<Item = (&str, bool)> {
    method iter_vars_mut (line 77) | pub fn iter_vars_mut(&mut self) -> impl Iterator<Item = &mut (String, ...
    method parse (line 94) | pub fn parse<'a>(args: impl IntoIterator<Item = &'a AST>, pos: SourceO...
    method len (line 102) | pub fn len(&self) -> usize {
    method is_empty (line 107) | pub fn is_empty(&self) -> bool {
    type Error (line 127) | type Error = ArgListParseErrorF;
    method try_from (line 129) | fn try_from(arglist: GeneralArgList) -> Result<Self, Self::Error> {
  method from (line 114) | fn from(arglist: ConstructorArgList) -> GeneralArgList {

FILE: src/ir/arglist/error.rs
  type ArgListParseErrorF (line 30) | pub enum ArgListParseErrorF {
  type ArgListParseError (line 57) | pub struct ArgListParseError {
    method new (line 63) | pub fn new(value: ArgListParseErrorF, pos: SourceOffset) -> ArgListPar...
    method fmt (line 69) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 97) | type Item = ArgListParseErrorF;
  method get_source (line 99) | fn get_source(&self) -> SourceOffset {
  method get_value (line 103) | fn get_value(&self) -> &ArgListParseErrorF {

FILE: src/ir/arglist/general.rs
  type GeneralArgList (line 32) | pub struct GeneralArgList {
    method empty (line 52) | pub fn empty() -> GeneralArgList {
  type GeneralArg (line 43) | pub struct GeneralArg {
    method simple (line 65) | pub fn simple(name: String) -> GeneralArg {
    method parse (line 72) | pub fn parse(ast: &AST) -> Result<GeneralArg, ArgListParseError> {
    method into_simple_name (line 93) | pub fn into_simple_name(self) -> Result<String, ArgListParseErrorF> {
  function parse_access_slot (line 107) | fn parse_access_slot(ast: &AST) -> Result<AccessSlotSyntax<'_>, ArgListP...
  function verify_self (line 113) | fn verify_self(ast: &AST) -> Result<(), ArgListParseError> {

FILE: src/ir/arglist/mod.rs
  function parse_ast (line 49) | fn parse_ast(input: &str) -> AST {
  function parse_arglist (line 53) | fn parse_arglist(input: &str) -> Result<ArgList, ArgListParseError> {
  function arglist (line 59) | fn arglist(req: Vec<&str>, opt: Vec<&str>, rest: Option<(&str, VarArg)>)...
  function gdarglist (line 67) | fn gdarglist(req: Vec<&str>) -> GDArgList {
  function into_gd (line 71) | fn into_gd(args: ArgList) -> (GDArgList, Vec<NameTrans>) {
  function test_parsing (line 77) | fn test_parsing() {
  function test_invalid_parse (line 90) | fn test_invalid_parse() {
  function test_arglist_gen (line 102) | fn test_arglist_gen() {

FILE: src/ir/arglist/ordinary.rs
  type ArgList (line 39) | pub struct ArgList {
    method empty (line 55) | pub fn empty() -> ArgList {
    method rest (line 66) | pub fn rest() -> ArgList {
    method required (line 76) | pub fn required(args: Vec<String>) -> ArgList {
    method from_specs (line 90) | pub fn from_specs(specs: FnSpecs) -> ArgList {
    method parse (line 100) | pub fn parse<'a>(args: impl IntoIterator<Item = &'a AST>, pos: SourceO...
    method into_gd_arglist (line 118) | pub fn into_gd_arglist(self, gen: &mut impl NameGenerator) -> (GDArgLi...
    method iter_vars (line 142) | pub fn iter_vars(&self) -> impl Iterator<Item = &str> {
    type Error (line 184) | type Error = ArgListParseErrorF;
    method try_from (line 186) | fn try_from(arglist: GeneralArgList) -> Result<Self, Self::Error> {
  method from (line 156) | fn from(arglist: ArgList) -> FnSpecs {
  method from (line 170) | fn from(arglist: ArgList) -> GeneralArgList {

FILE: src/ir/arglist/parser.rs
  type ParseState (line 35) | pub enum ParseState {
    constant START_STATE (line 96) | pub const START_STATE: ParseState =
    method state_transition (line 106) | pub fn state_transition(self, arg: &str) -> Option<ParseState> {
    method parse_once (line 117) | pub fn parse_once(&mut self, arglist: &mut GeneralArgList, arg: &AST) ...
    method parse_state_transition (line 149) | fn parse_state_transition(&mut self, arg: &AST) -> Result<bool, ArgLis...
  method partial_cmp (line 67) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  function parse (line 179) | pub fn parse<'a>(args: impl IntoIterator<Item = &'a AST>)

FILE: src/ir/arglist/simple.rs
  type SimpleArgList (line 39) | pub struct SimpleArgList {
    method into_gd_arglist (line 49) | pub fn into_gd_arglist(self, gen: &mut impl NameGenerator) -> (GDArgLi...
    method iter_vars (line 55) | pub fn iter_vars(&self) -> impl Iterator<Item = &str> {
    method parse (line 63) | pub fn parse<'a>(args: impl IntoIterator<Item = &'a AST>, pos: SourceO...
    method len (line 71) | pub fn len(&self) -> usize {
    method is_empty (line 76) | pub fn is_empty(&self) -> bool {
    type Error (line 94) | type Error = ArgListParseErrorF;
    method try_from (line 96) | fn try_from(arglist: GeneralArgList) -> Result<Self, Self::Error> {
  method from (line 83) | fn from(arglist: SimpleArgList) -> GeneralArgList {
  method from (line 108) | fn from(arglist: SimpleArgList) -> ArgList {

FILE: src/ir/arglist/vararg.rs
  type VarArg (line 26) | pub enum VarArg {
    constant NONE (line 36) | pub const NONE: i32 = 0;
    method into_constant (line 41) | pub fn into_constant(self) -> i32 {
    method arg_to_const (line 50) | pub fn arg_to_const(opt: Option<VarArg>) -> i32 {

FILE: src/ir/bootstrapping.rs
  function compile_bootstrapping_decl (line 29) | pub fn compile_bootstrapping_decl(
  function compile_bootstrapping_class_inner_decl (line 57) | pub fn compile_bootstrapping_class_inner_decl(
  function compile_bootstrapping_expr (line 76) | pub fn compile_bootstrapping_expr(
  function bootstrap_constant_names (line 93) | fn bootstrap_constant_names(
  function declare_superglobal (line 102) | fn declare_superglobal(name: &str, pos: SourceOffset) -> Decl {
  function bootstrap_constant_enums (line 116) | fn bootstrap_constant_enums(
  function bootstrap_non_singletons (line 128) | fn bootstrap_non_singletons(
  function bootstrap_singletons (line 137) | fn bootstrap_singletons(
  function bootstrap_singleton_backing_types (line 146) | fn bootstrap_singleton_backing_types(

FILE: src/ir/call_name.rs
  type CallName (line 37) | pub enum CallName {
    method resolve_call_name (line 55) | pub fn resolve_call_name(icompiler: &mut IncCompiler,
    method into_expr (line 76) | pub fn into_expr(self,
    method try_resolve_method_name (line 103) | fn try_resolve_method_name(ast: &AST) -> Option<(&AST, &str)> {
    method try_resolve_atomic_name (line 116) | fn try_resolve_atomic_name(ast: &AST) -> Option<&str> {
  function parse_ast (line 141) | fn parse_ast(input: &str) -> AST {
  function dummy_config (line 145) | fn dummy_config() -> ProjectConfig {
  function dummy_pipeline (line 153) | fn dummy_pipeline() -> Pipeline {
  function resolve_call (line 157) | fn resolve_call(input: &str) -> Result<CallName, PError> {
  function simple_call_name (line 164) | fn simple_call_name() {
  function method_name (line 181) | fn method_name() {
  function super_name (line 187) | fn super_name() {
  function atomic_name (line 192) | fn atomic_name() {

FILE: src/ir/classification.rs
  type DetectedSuperCall (line 31) | pub struct DetectedSuperCall<'a> {
  constant DECL_HEADS (line 42) | pub const DECL_HEADS: [&str; 9] = [
  function is_decl (line 63) | pub fn is_decl(decl: &AST) -> bool {
  function detect_super (line 80) | pub fn detect_super<'a, 'b>(body: &'a [&'b AST]) -> (Option<DetectedSupe...
  function parse_ast (line 103) | fn parse_ast(input: &str) -> AST {
  function is_decl_test (line 108) | fn is_decl_test() {
  function is_not_decl_test (line 120) | fn is_not_decl_test() {

FILE: src/ir/closure_names.rs
  type ClosureNames (line 36) | pub struct ClosureNames<T : Lattice>(HashMap<String, (T, SourceOffset)>);
  function new (line 41) | pub fn new() -> Self {
  function from_hashmap (line 47) | pub fn from_hashmap(map: HashMap<String, (T, SourceOffset)>) -> Self {
  function get (line 54) | pub fn get(&self, name: &str) -> Option<&T> {
  function contains (line 60) | pub fn contains(&self, name: &str) -> bool {
  function visit (line 74) | pub fn visit(&mut self, name: String, usage: T, pos: SourceOffset) {
  function remove (line 83) | pub fn remove(&mut self, name: &str) -> Option<T> {
  function names (line 88) | pub fn names(&self) -> impl Iterator<Item=&str> {
  function into_names (line 94) | pub fn into_names(self) -> impl Iterator<Item=String> {
  function is_empty (line 99) | pub fn is_empty(&self) -> bool {
  function merge_with (line 106) | pub fn merge_with(&mut self, b: ClosureNames<T>) {
  function retain (line 114) | pub fn retain(&mut self, mut f: impl FnMut(&str, &mut T) -> bool) {
  function iter (line 121) | pub fn iter(&self) -> impl Iterator<Item=(&str, &T)> {
  function iter_mut (line 127) | pub fn iter_mut(&mut self) -> impl Iterator<Item=(&str, &mut T)> {
  function into_iter_with_offset (line 132) | pub fn into_iter_with_offset(self) -> impl Iterator<Item=(String, T, Sou...
  function iter_with_offset (line 137) | pub fn iter_with_offset(&self) -> impl Iterator<Item=(&str, &T, SourceOf...
  method default (line 144) | fn default() -> Self {

FILE: src/ir/decl.rs
  type TopLevel (line 40) | pub struct TopLevel {
    method new (line 233) | pub fn new() -> TopLevel {
    method find_main_class (line 241) | pub fn find_main_class(&self) -> Result<Option<&ClassDecl>, DuplicateM...
    method inner_exprs (line 271) | pub fn inner_exprs(&self) -> impl Iterator<Item=&Expr> + '_ {
  type DeclF (line 47) | pub enum DeclF {
  type Decl (line 58) | pub struct Decl {
    method new (line 279) | pub fn new(value: DeclF, pos: SourceOffset) -> Decl {
    method to_id (line 283) | pub fn to_id(&self) -> Id {
    method id_like (line 287) | pub fn id_like<'a>(&'a self) -> Box<dyn IdLike<NS=Namespace> + 'a> {
    method name (line 291) | pub fn name(&self) -> &str {
    method dependencies (line 304) | pub fn dependencies(&self) -> HashMap<Id, SourceOffset> {
    method is_macro (line 353) | pub fn is_macro(&self) -> bool {
    method is_exported_by_default (line 358) | pub fn is_exported_by_default(&self) -> bool {
    method namespace (line 364) | pub fn namespace(&self) -> Namespace {
    method visibility (line 376) | pub fn visibility(&self) -> Visibility {
    method visibility_mut (line 388) | pub fn visibility_mut(&mut self) -> &mut Visibility {
    method inner_exprs (line 400) | pub fn inner_exprs(&self) -> Box<dyn Iterator<Item=&Expr> + '_> {
  type FnDecl (line 64) | pub struct FnDecl {
  type MacroDecl (line 73) | pub struct MacroDecl {
    method from (line 702) | fn from(decl: SymbolMacroDecl) -> MacroDecl {
  type SymbolMacroDecl (line 81) | pub struct SymbolMacroDecl {
  type ConstDecl (line 88) | pub struct ConstDecl {
  type EnumDecl (line 95) | pub struct EnumDecl {
    method value_names (line 425) | pub fn value_names(&self) -> impl Iterator<Item=&str> {
  type ClassDecl (line 102) | pub struct ClassDecl {
    method new (line 433) | pub fn new(name: String, extends: String) -> ClassDecl {
    method constructor_or_default (line 448) | pub fn constructor_or_default(&self, default_pos: SourceOffset) -> Cow...
  type ConstructorDecl (line 112) | pub struct ConstructorDecl {
    method empty (line 458) | pub fn empty(pos: SourceOffset) -> ConstructorDecl {
    method dependencies (line 466) | pub fn dependencies(&self) -> HashMap<Id, SourceOffset> {
    method get_names (line 484) | pub fn get_names(&self) -> (Locals, Functions) {
  type SuperCall (line 119) | pub struct SuperCall {
    method empty (line 503) | pub fn empty(pos: SourceOffset) -> SuperCall {
  type ClassInnerDeclF (line 125) | pub enum ClassInnerDeclF {
  type ClassInnerDecl (line 133) | pub struct ClassInnerDecl {
    method new (line 511) | pub fn new(value: ClassInnerDeclF, pos: SourceOffset) -> ClassInnerDecl {
    method dependencies (line 515) | pub fn dependencies(&self) -> HashMap<Id, SourceOffset> {
    method name (line 531) | pub fn name(&self) -> Cow<str> {
    method namespace (line 540) | pub fn namespace(&self) -> ClassNamespace {
    method get_names (line 549) | pub fn get_names(&self) -> (Locals, Functions) {
    method is_static (line 574) | pub fn is_static(&self) -> bool {
    method inner_exprs (line 582) | pub fn inner_exprs(&self) -> Box<dyn Iterator<Item=&Expr> + '_> {
  type ClassSignalDecl (line 139) | pub struct ClassSignalDecl {
  type ClassVarDecl (line 145) | pub struct ClassVarDecl {
  type ClassFnDecl (line 153) | pub struct ClassFnDecl {
  type DeclareDecl (line 179) | pub struct DeclareDecl {
  type DeclareType (line 190) | pub enum DeclareType {
    method namespace (line 595) | pub fn namespace(&self) -> Namespace {
  type Export (line 211) | pub struct Export {
  type InstanceFunctionName (line 218) | pub enum InstanceFunctionName {
    method parse (line 623) | pub fn parse(ast: &AST) -> Option<InstanceFunctionName> {
    method method_name (line 648) | pub fn method_name(&self) -> Cow<str> {
    method is_constructor_function (line 659) | pub fn is_constructor_function(&self) -> bool {
  type DuplicateMainClassError (line 229) | pub struct DuplicateMainClassError(pub SourceOffset);
  type Item (line 670) | type Item = DeclF;
  method get_source (line 672) | fn get_source(&self) -> SourceOffset {
  method get_value (line 676) | fn get_value(&self) -> &DeclF {
  type Item (line 683) | type Item = ClassInnerDeclF;
  method get_source (line 685) | fn get_source(&self) -> SourceOffset {
  method get_value (line 689) | fn get_value(&self) -> &ClassInnerDeclF {
  method from (line 696) | fn from(d: DeclareType) -> Namespace {
  function from (line 713) | fn from(arg: (ClassDecl, Vec<Expr>)) -> expr::LambdaClass {
  function parse_ast (line 729) | fn parse_ast(input: &str) -> AST {
  function sample_class (line 733) | fn sample_class(class_name: &str, main_class: bool) -> ClassDecl {
  function find_main_class_test_1 (line 745) | fn find_main_class_test_1() {
  function find_main_class_test_2 (line 758) | fn find_main_class_test_2() {
  function find_main_class_test_3 (line 771) | fn find_main_class_test_3() {
  function find_main_class_test_4 (line 784) | fn find_main_class_test_4() {
  function find_main_class_test_5 (line 797) | fn find_main_class_test_5() {
  function parse_instance_function_name_test (line 812) | fn parse_instance_function_name_test() {
  function parse_instance_function_name_failures_test (line 829) | fn parse_instance_function_name_failures_test() {
  function is_constructor_name_test (line 841) | fn is_constructor_name_test() {

FILE: src/ir/declaration_table.rs
  type DeclarationTable (line 37) | pub struct DeclarationTable {
    method new (line 45) | pub fn new() -> DeclarationTable {
    method get (line 50) | pub fn get<'a>(&self, id: &(dyn IdLike<NS=Namespace> + 'a)) -> Option<...
    method add (line 59) | pub fn add(&mut self, value: Decl) -> Option<Decl> {
    method add_unless_exists (line 76) | pub fn add_unless_exists(&mut self, value: Decl) -> Result<(), GDError> {
    method del (line 90) | pub fn del<'a>(&mut self, id: &(dyn IdLike<NS=Namespace> + 'a)) -> Opt...
    method has (line 108) | pub fn has<'a>(&self, id: &(dyn IdLike<NS=Namespace> + 'a)) -> bool {
    method filter (line 115) | pub fn filter(&self, condition: impl FnMut(&Decl) -> bool) -> Declarat...
    method iter (line 122) | pub fn iter(&self) -> impl Iterator<Item=&Decl> {
    method from (line 138) | fn from(decls: Vec<Decl>) -> DeclarationTable {
  function from (line 130) | fn from(table: DeclarationTable) -> Vec<Decl> {

FILE: src/ir/depends.rs
  type Dependencies (line 26) | pub struct Dependencies {
    method identify (line 39) | pub fn identify<'a>(table: &DeclarationTable,
    method purge_unknowns (line 84) | pub fn purge_unknowns<'a, 'b, I>(&mut self, purge: I)
    method try_into_knowns (line 92) | pub fn try_into_knowns(self) -> Result<HashSet<Id>, DependencyError> {
  type DependencyError (line 33) | pub enum DependencyError {

FILE: src/ir/export.rs
  type Visibility (line 28) | pub enum Visibility { Public, Private }
    constant FUNCTION (line 33) | pub const FUNCTION: Visibility = Visibility::Public;
    constant MACRO (line 36) | pub const MACRO: Visibility = Visibility::Public;
    constant SYMBOL_MACRO (line 39) | pub const SYMBOL_MACRO: Visibility = Visibility::Public;
    constant CONST (line 42) | pub const CONST: Visibility = Visibility::Public;
    constant CLASS (line 45) | pub const CLASS: Visibility = Visibility::Public;
    constant OBJECT (line 48) | pub const OBJECT: Visibility = Visibility::Public;
    constant ENUM (line 51) | pub const ENUM: Visibility = Visibility::Public;
    constant DECLARE (line 54) | pub const DECLARE: Visibility = Visibility::Private;
  function get_export_list (line 60) | pub fn get_export_list<'a>(decls: impl IntoIterator<Item=&'a Decl>) -> V...

FILE: src/ir/expr.rs
  constant DEFAULT_SPLIT_NAME (line 36) | pub const DEFAULT_SPLIT_NAME: &str = "_split";
  type ExprF (line 39) | pub enum ExprF {
    method from (line 545) | fn from(value: T) -> ExprF {
  type Expr (line 67) | pub struct Expr {
    method new (line 170) | pub fn new(value: ExprF, pos: SourceOffset) -> Expr {
    method var (line 174) | pub fn var(name: impl Into<String>, pos: SourceOffset) -> Expr {
    method atomic_var (line 178) | pub fn atomic_var(name: impl Into<String>, pos: SourceOffset) -> Expr {
    method while_stmt (line 182) | pub fn while_stmt(cond: Expr, body: Expr, pos: SourceOffset) -> Expr {
    method for_stmt (line 186) | pub fn for_stmt(name: String, iter: Expr, body: Expr, pos: SourceOffse...
    method literal (line 190) | pub fn literal(literal: literal::Literal, pos: SourceOffset) -> Expr {
    method nil (line 194) | pub fn nil(pos: SourceOffset) -> Expr {
    method progn (line 198) | pub fn progn(body: Vec<Expr>, pos: SourceOffset) -> Expr {
    method call (line 202) | pub fn call(name: impl Into<String>, args: Vec<Expr>, pos: SourceOffse...
    method atomic_call (line 206) | pub fn atomic_call(name: impl Into<String>, args: Vec<Expr>, pos: Sour...
    method super_call (line 210) | pub fn super_call(name: impl Into<String>, args: Vec<Expr>, pos: Sourc...
    method method_call (line 214) | pub fn method_call(self, name: impl Into<String>, args: Vec<Expr>, pos...
    method yield_none (line 218) | pub fn yield_none(pos: SourceOffset) -> Expr {
    method yield_some (line 222) | pub fn yield_some(lhs: Expr, rhs: Expr, pos: SourceOffset) -> Expr {
    method assert_expr (line 226) | pub fn assert_expr(cond: Expr, message: Option<Expr>, pos: SourceOffse...
    method as_plain_name (line 232) | pub fn as_plain_name(&self) -> Option<&str> {
    method from_ast_literal (line 242) | pub fn from_ast_literal(ast_literal: &ASTLiteral, pos: SourceOffset) -...
    method self_evaluating_lambda (line 274) | pub fn self_evaluating_lambda(self) -> Expr {
    method from_value (line 283) | pub fn from_value<T>(value: T, pos: SourceOffset) -> Expr
    method named_split (line 288) | pub fn named_split(self, name: &str, pos: SourceOffset) -> Expr {
    method split (line 292) | pub fn split(self, pos: SourceOffset) -> Expr {
    method walk_locals (line 296) | fn walk_locals(&self, acc_vars: &mut Locals, acc_fns: &mut Functions) {
    method get_locals (line 495) | pub fn get_locals(&self) -> Locals {
    method get_functions (line 501) | pub fn get_functions(&self) -> Functions {
    method get_names (line 505) | pub fn get_names(&self) -> (Locals, Functions) {
    method get_ids (line 512) | pub fn get_ids(&self) -> impl Iterator<Item=(Id, SourceOffset)> {
  type AssignTarget (line 73) | pub enum AssignTarget {
  type CallTarget (line 80) | pub enum CallTarget {
  type BareName (line 103) | pub enum BareName {
    method to_gd_name (line 552) | pub fn to_gd_name(&self) -> String {
    method to_gd_name_bare (line 559) | pub fn to_gd_name_bare(&self) -> String {
  type FuncRefTarget (line 112) | pub enum FuncRefTarget {
  type FunctionBindingType (line 119) | pub enum FunctionBindingType {
    method into_local_binding (line 575) | pub fn into_local_binding(self) -> Box<dyn local_binding::LocalBinding> {
  type LambdaClass (line 134) | pub struct LambdaClass {
    method constructor_or_default (line 524) | pub fn constructor_or_default(&self, default_pos: SourceOffset) -> Cow...
  type LocalFnClause (line 142) | pub struct LocalFnClause {
  type LocalVarClause (line 149) | pub struct LocalVarClause {
  type Locals (line 156) | pub type Locals = ClosureNames<AccessType>;
  type Functions (line 166) | pub type Functions = ClosureNames<()>;
  type Item (line 531) | type Item = ExprF;
  method get_source (line 533) | fn get_source(&self) -> SourceOffset {
  method get_value (line 537) | fn get_value(&self) -> &ExprF {
  function lhash (line 589) | fn lhash(vec: Vec<String>) -> Locals {
  function lhash_rw (line 593) | fn lhash_rw(vec: Vec<(String, AccessType)>) -> Locals {
  function fhash (line 597) | fn fhash(vec: Vec<String>) -> Functions {
  function lvc (line 601) | fn lvc(name: &str, value: Expr) -> LocalVarClause {
  function e (line 611) | fn e(expr: ExprF) -> Expr {
  function test_locals_simple (line 616) | fn test_locals_simple() {
  function test_locals_compound (line 625) | fn test_locals_compound() {
  function test_locals_super_call (line 632) | fn test_locals_super_call() {
  function test_locals_let (line 638) | fn test_locals_let() {
  function test_locals_assignment (line 668) | fn test_locals_assignment() {
  function test_locals_slot_assignment (line 695) | fn test_locals_slot_assignment() {
  function test_functions_trivial (line 716) | fn test_functions_trivial() {
  function test_functions_calls (line 722) | fn test_functions_calls() {
  function test_functions_ref (line 728) | fn test_functions_ref() {
  function test_function_binding_type_local_binding_inverse (line 734) | fn test_function_binding_type_local_binding_inverse() {

FILE: src/ir/identifier.rs
  type Id (line 29) | pub struct Id {
    method new (line 109) | pub fn new(namespace: Namespace, name: String) -> Self {
    method build (line 116) | pub fn build<'a, NS: Clone + 'a>(namespace: NS, name: &'a str) -> Box<...
    method borrow (line 186) | fn borrow(&self) -> &(dyn IdLike<NS=Namespace> + 'a) {
  type Namespace (line 39) | pub enum Namespace {
    method name (line 124) | pub fn name(self) -> &'static str {
  type ClassNamespace (line 55) | pub enum ClassNamespace {
    method from (line 97) | fn from(ns: Namespace) -> ClassNamespace {
    method name (line 133) | pub fn name(self) -> &'static str {
  type IdLike (line 80) | pub trait IdLike {
    method namespace (line 88) | fn namespace(&self) -> Self::NS;
    method name (line 91) | fn name(&self) -> &str;
    type NS (line 145) | type NS = Namespace;
    method namespace (line 147) | fn namespace(&self) -> Namespace {
    method name (line 151) | fn name(&self) -> &str {
    type NS (line 159) | type NS = NS;
    method namespace (line 161) | fn namespace(&self) -> NS {
    method name (line 165) | fn name(&self) -> &str {
    type NS (line 173) | type NS = NS;
    method namespace (line 175) | fn namespace(&self) -> NS {
    method name (line 179) | fn name(&self) -> &str {
  function borrow (line 192) | fn borrow(&self) -> &(dyn IdLike<NS=NS> + 'a) {
  method hash (line 198) | fn hash<H : Hasher>(&self, state: &mut H) {
  method eq (line 205) | fn eq(&self, other: &Self) -> bool {
  type Owned (line 213) | type Owned = Id;
  method to_owned (line 214) | fn to_owned(&self) -> Id {
  function test_id_in_hashmap (line 225) | fn test_id_in_hashmap() {
  function test_id_in_hashset (line 232) | fn test_id_in_hashset() {

FILE: src/ir/import.rs
  type ImportDecl (line 52) | pub struct ImportDecl {
    method default_import_name (line 89) | pub fn default_import_name(path: &RPathBuf) -> String {
    method parse_path_param (line 100) | pub fn parse_path_param(arg: &str) -> Option<RPathBuf> {
    method named (line 107) | pub fn named(filename: RPathBuf, name: Option<String>, pos: SourceOffs...
    method restricted (line 116) | pub fn restricted(filename: RPathBuf, imports: Vec<ImportName<Option<N...
    method open (line 124) | pub fn open(filename: RPathBuf, pos: SourceOffset) -> ImportDecl {
    method names (line 132) | pub fn names(&self, exports: &[Id]) -> Vec<ImportName<Namespace>> {
    method parse (line 155) | pub fn parse(tail: &[&AST]) -> Result<ImportDecl, ImportDeclParseError> {
  type ImportDetails (line 59) | pub enum ImportDetails {
  type ImportName (line 66) | pub struct ImportName<NS> {
  type ImportDeclParseError (line 73) | pub enum ImportDeclParseError {
    method fmt (line 309) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ImportNameResolutionError (line 82) | pub enum ImportNameResolutionError {
    method fmt (line 331) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 210) | pub fn new(namespace: NS, in_name: String, out_name: String) -> ImportNa...
  function simple (line 214) | pub fn simple(namespace: NS, in_name: String) -> ImportName<NS> {
  function symbol_to_namespace (line 219) | fn symbol_to_namespace(symbol: &str, pos: SourceOffset) -> Result<Namesp...
  function parse (line 227) | pub fn parse(clause: &AST) -> Result<ImportName<Option<Namespace>>, Impo...
  function refine (line 265) | pub fn refine(&self, exports: &[Id]) -> Result<ImportName<Namespace>, Im...
  function into_imported_id (line 285) | pub fn into_imported_id(self) -> Id {
  function into_exported_id (line 289) | pub fn into_exported_id(self) -> Id {
  function to_imported_id (line 293) | pub fn to_imported_id<'a>(&'a self) -> Box<dyn IdLike<NS=Namespace> + 'a> {
  function to_exported_id (line 297) | pub fn to_exported_id<'a>(&'a self) -> Box<dyn IdLike<NS=Namespace> + 'a> {
  function invalid_ending_err (line 303) | fn invalid_ending_err(tail: &[&AST], pos: SourceOffset) -> ImportDeclPar...
  function parse_ast (line 350) | fn parse_ast(input: &str) -> AST {
  function parse_import (line 354) | fn parse_import(input: &str) -> Result<ImportDecl, ImportDeclParseError> {
  function str_to_rpathbuf (line 360) | fn str_to_rpathbuf(input: &str) -> RPathBuf {
  function so (line 364) | fn so(x: usize) -> SourceOffset {
  function default_import_name_test_relative (line 369) | fn default_import_name_test_relative() {
  function default_import_name_test_absolute_windows (line 378) | fn default_import_name_test_absolute_windows() {
  function default_import_name_test_absolute_unix (line 385) | fn default_import_name_test_absolute_unix() {
  function test_parsing (line 391) | fn test_parsing() {
  function test_invalid_parsing (line 424) | fn test_invalid_parsing() {

FILE: src/ir/incremental.rs
  type IncCompiler (line 67) | pub struct IncCompiler {
    method new (line 79) | pub fn new(names: Vec<&str>) -> IncCompiler {
    method with_ambient_symbols (line 83) | pub fn with_ambient_symbols(names: Vec<&str>, ambient_symbols: SymbolT...
    method resolve_macro_call (line 95) | fn resolve_macro_call<K: IdLike>(&mut self,
    method try_resolve_macro_call (line 136) | fn try_resolve_macro_call(&mut self, pipeline: &mut Pipeline, ast: &AS...
    method try_resolve_symbol_macro_call (line 154) | fn try_resolve_symbol_macro_call(&mut self, pipeline: &mut Pipeline, h...
    method resolve_simple_call (line 162) | pub fn resolve_simple_call(&mut self, pipeline: &mut Pipeline, head: &...
    method compile_expr (line 176) | pub fn compile_expr(&mut self, pipeline: &mut Pipeline, expr: &AST) ->...
    method compile_decl (line 203) | pub fn compile_decl(&mut self,
    method compile_class_inner_decl (line 423) | pub fn compile_class_inner_decl(&mut self,
    method compile_import (line 604) | pub fn compile_import(&mut self, curr: &AST) -> Result<Option<ImportDe...
    method import_macros_from (line 613) | fn import_macros_from(&mut self, unit: &TranslationUnit, import: &Impo...
    method compile_decl_or_expr (line 622) | fn compile_decl_or_expr(&mut self, pipeline: &mut Pipeline, main: &mut...
    method compile_toplevel (line 667) | pub fn compile_toplevel(mut self, pipeline: &mut Pipeline, body: &AST,...
    method bind_macro (line 690) | pub fn bind_macro(&mut self, pipeline: &mut Pipeline, mut decl: decl::...
    method locally_save_macro (line 768) | pub fn locally_save_macro<B, K>(&mut self, name: &K, func: impl FnOnce...
    method has_macro (line 779) | pub fn has_macro<K>(&self, name: &K) -> bool
    method unbind_macro (line 785) | pub fn unbind_macro<K>(&mut self, name: &K)
    method bind_builtin_macros (line 791) | pub fn bind_builtin_macros(&mut self, pipeline: &mut Pipeline) {
    method bind_macros_from (line 797) | pub fn bind_macros_from(&mut self, existing_macros: impl IntoIterator<...
    method declaration_table (line 801) | pub fn declaration_table(&mut self) -> &mut DeclarationTable {
    method mark_as_minimalist (line 805) | pub fn mark_as_minimalist(&mut self) {
    method name_generator (line 809) | pub fn name_generator(&mut self) -> &mut FreshNameGenerator {
    method get_declare_decl_name (line 825) | fn get_declare_decl_name(form: &AST) -> Result<(String, Option<String>...
  function from (line 857) | fn from(compiler: IncCompiler) -> (decl::TopLevel, HashMap<Id, MacroData...
  function dummy_config (line 881) | fn dummy_config() -> ProjectConfig {
  function dummy_pipeline (line 889) | fn dummy_pipeline() -> Pipeline {
  function bad_call_test (line 894) | fn bad_call_test() {

FILE: src/ir/literal.rs
  type Literal (line 24) | pub enum Literal {
    method from (line 34) | fn from(value: i32) -> Literal {
    method from (line 40) | fn from(value: OrderedFloat<f32>) -> Literal {
    method from (line 46) | fn from(value: String) -> Literal {
    method from (line 52) | fn from(value: &'a str) -> Literal {
    method from (line 58) | fn from(value: bool) -> Literal {

FILE: src/ir/loops/error.rs
  type LoopPrimitiveErrorF (line 28) | pub struct LoopPrimitiveErrorF {
  type LoopPrimitiveError (line 40) | pub struct LoopPrimitiveError {
    method new (line 52) | pub fn new(value: LoopPrimitiveErrorF, pos: SourceOffset) -> LoopPrimi...
    method break_error (line 56) | pub fn break_error(pos: SourceOffset) -> LoopPrimitiveError {
    method continue_error (line 63) | pub fn continue_error(pos: SourceOffset) -> LoopPrimitiveError {
    method in_closure (line 70) | pub fn in_closure(mut self) -> Self {
    method fmt (line 91) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LoopPrimitive (line 46) | pub enum LoopPrimitive {
    method fmt (line 102) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 78) | type Item = LoopPrimitiveErrorF;
  method get_source (line 80) | fn get_source(&self) -> SourceOffset {
  method get_value (line 84) | fn get_value(&self) -> &LoopPrimitiveErrorF {

FILE: src/ir/loops/mod.rs
  type LoopWalker (line 29) | enum LoopWalker {
    method new (line 60) | fn new() -> Self {
    method enter_loop (line 64) | fn enter_loop(self) -> Self {
    method enter_closure (line 68) | fn enter_closure(self) -> Self {
    method check (line 77) | fn check(self, expr: &Expr) -> Result<(), LoopPrimitiveError> {
    method check_loop_primitive (line 200) | fn check_loop_primitive(self, primitive: LoopPrimitive, pos: SourceOff...
  function check_expr (line 47) | pub fn check_expr(expr: &Expr) -> Result<(), LoopPrimitiveError> {
  function check_all_exprs (line 51) | pub fn check_all_exprs(toplevel: &TopLevel) -> Result<(), LoopPrimitiveE...

FILE: src/ir/macros.rs
  type MacroData (line 45) | pub struct MacroData {
    method to_imported (line 61) | pub fn to_imported(&self) -> MacroData {
  function make_tmp (line 51) | fn make_tmp() -> io::Result<NamedTempFile> {
  function create_macro_file (line 69) | pub fn create_macro_file(pipeline: &mut Pipeline, imports: Vec<ImportDec...

FILE: src/ir/main_function.rs
  type DisallowMainFunctionHandler (line 32) | pub struct DisallowMainFunctionHandler;
  type StaticMainFunctionHandler (line 43) | pub struct StaticMainFunctionHandler {
    method new (line 77) | pub fn new(function_name: String) -> Self {
  type MainFunctionHandler (line 57) | pub trait MainFunctionHandler {
    method handle_main (line 59) | fn handle_main(&self, icompiler: &mut IncCompiler, main: &[Expr]) -> R...
    method handle_main (line 65) | fn handle_main(&self, _icompiler: &mut IncCompiler, main: &[Expr]) -> ...
    method handle_main (line 85) | fn handle_main(&self, icompiler: &mut IncCompiler, main: &[Expr]) -> R...

FILE: src/ir/mod.rs
  function compile_toplevel (line 61) | pub fn compile_toplevel(pipeline: &mut Pipeline, body: &AST, main_functi...
  function compile_and_check (line 67) | pub fn compile_and_check(pipeline: &mut Pipeline, body: &AST, main_funct...
  function check_ir (line 74) | pub fn check_ir(ir: &decl::TopLevel) -> Result<(), GDError> {
  function int (line 96) | fn int(n: i32) -> AST {
  function symbol (line 100) | fn symbol(s: &str) -> AST {
  function string (line 105) | fn string(s: &str) -> AST {
  function nil (line 109) | fn nil() -> AST {
  function cons (line 114) | fn cons(a: AST, b: AST) -> AST {
  function list (line 118) | fn list(data: Vec<AST>) -> AST {
  function call (line 122) | fn call(name: &str, args: Vec<Expr>) -> Expr {
  function literal (line 126) | fn literal(literal: Literal) -> Expr {
  function progn (line 130) | fn progn(body: Vec<Expr>) -> Expr {
  function compile_expr (line 134) | fn compile_expr(pipeline: &mut Pipeline, expr: &AST)
  function compile_decl (line 141) | fn compile_decl(pipeline: &mut Pipeline, decl: &AST)
  function do_compile_expr (line 151) | fn do_compile_expr(expr: &AST) -> Result<Expr, PError> {
  function do_compile_decl (line 156) | fn do_compile_decl(decl: &AST) -> Result<Decl, PError> {
  function compile_call (line 162) | fn compile_call() {
  function compile_builtin (line 172) | fn compile_builtin() {
  function compile_int (line 180) | fn compile_int() {
  function compile_nil (line 186) | fn compile_nil() {
  function compile_progn (line 191) | fn compile_progn() {
  function compile_defn (line 201) | fn compile_defn() {
  function compile_defmacro (line 217) | fn compile_defmacro() {
  function compile_set (line 232) | fn compile_set() {

FILE: src/ir/modifier/class.rs
  type ClassMod (line 27) | pub enum ClassMod {
    method apply (line 37) | pub fn apply(&self, decl: &mut ClassDecl) {
  function parser (line 50) | pub fn parser() -> impl ParseRule<Modifier=ClassMod> {

FILE: src/ir/modifier/constant.rs
  type ConstMod (line 27) | pub enum ConstMod {
    method apply (line 34) | pub fn apply(&self, decl: &mut ConstDecl) {
  function parser (line 44) | pub fn parser() -> impl ParseRule<Modifier=ConstMod> {

FILE: src/ir/modifier/declare.rs
  type DeclareMod (line 27) | pub enum DeclareMod {
    method apply (line 34) | pub fn apply(&self, decl: &mut DeclareDecl) {
  function parser (line 44) | pub fn parser() -> impl ParseRule<Modifier=DeclareMod> {

FILE: src/ir/modifier/enums.rs
  type EnumMod (line 27) | pub enum EnumMod {
    method apply (line 34) | pub fn apply(&self, decl: &mut EnumDecl) {
  function parser (line 44) | pub fn parser() -> impl ParseRule<Modifier=EnumMod> {

FILE: src/ir/modifier/file.rs
  type FileMod (line 29) | pub enum FileMod {
    method apply (line 46) | pub fn apply(&self, icompiler: &mut IncCompiler) {
  type NoStdLibParser (line 41) | pub struct NoStdLibParser;
  type Modifier (line 57) | type Modifier = ();
  method name (line 59) | fn name(&self) -> &str {
  method parse_once (line 63) | fn parse_once(&mut self, ast: &AST) -> Result<(), ParseError> {
  function file_error (line 78) | fn file_error(ast: &AST) -> ParseError {
  function parser (line 83) | pub fn parser() -> impl ParseRule<Modifier=FileMod> {

FILE: src/ir/modifier/function.rs
  type FnMod (line 32) | pub enum FnMod {
    method apply (line 41) | pub fn apply(&self, decl: &mut FnDecl) {
  function parser (line 54) | pub fn parser() -> impl ParseRule<Modifier=FnMod> {

FILE: src/ir/modifier/instance_method.rs
  type MethodMod (line 28) | pub enum MethodMod {
    method apply (line 40) | pub fn apply(&self, decl: &mut ClassFnDecl) {
    method apply_to_constructor (line 54) | pub fn apply_to_constructor(&self, decl: &mut ConstructorDecl) -> Resu...
  function parser (line 67) | pub fn parser() -> impl ParseRule<Modifier=MethodMod> {

FILE: src/ir/modifier/macros.rs
  type MacroMod (line 27) | pub enum MacroMod {
    method apply (line 33) | pub fn apply(&self, decl: &mut MacroDecl) {
    method apply_to_symbol_macro (line 41) | pub fn apply_to_symbol_macro(&self, decl: &mut SymbolMacroDecl) {
  function parser (line 51) | pub fn parser() -> impl ParseRule<Modifier=MacroMod> {

FILE: src/ir/modifier/magic.rs
  type MagicParser (line 35) | pub struct MagicParser;
  type Modifier (line 38) | type Modifier = String;
  method name (line 40) | fn name(&self) -> &str {
  method parse_once (line 44) | fn parse_once(&mut self, ast: &AST) -> Result<String, ParseError> {
  function magic_error (line 61) | fn magic_error(ast: &AST) -> ParseError {
  function parser (line 66) | pub fn parser() -> impl ParseRule<Modifier=String> {

FILE: src/ir/modifier/mod.rs
  type Constant (line 49) | pub struct Constant<M> {
  type Several (line 60) | pub struct Several<'a, M> {
  type Map (line 72) | pub struct Map<R, F> {
  type Unique (line 81) | pub struct Unique<R> {
  type ParseErrorF (line 95) | pub enum ParseErrorF {
  type ParseError (line 109) | pub struct ParseError {
    method new (line 178) | pub fn new(value: ParseErrorF, pos: SourceOffset) -> ParseError {
    method is_fatal (line 185) | pub fn is_fatal(&self) -> bool {
    method fmt (line 209) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ParseRule (line 117) | pub trait ParseRule {
    method parse_once (line 125) | fn parse_once(&mut self, ast: &AST) -> Result<Self::Modifier, ParseErr...
    method name (line 129) | fn name(&self) -> &str;
    method parse (line 139) | fn parse<'a, 'b>(&mut self, args: &'a [&'b AST]) -> Result<(Vec<Self::...
    method map (line 159) | fn map<N, F>(self, f: F) -> Map<Self, F>
    method unique (line 169) | fn unique(self) -> Unique<Self>
    type Modifier (line 233) | type Modifier = M;
    method parse_once (line 235) | fn parse_once(&mut self, ast: &AST) -> Result<M, ParseError> {
    method name (line 243) | fn name(&self) -> &str {
    type Modifier (line 264) | type Modifier = M;
    method parse_once (line 266) | fn parse_once(&mut self, ast: &AST) -> Result<M, ParseError> {
    method name (line 283) | fn name(&self) -> &str {
    type Modifier (line 292) | type Modifier = N;
    method parse_once (line 294) | fn parse_once(&mut self, ast: &AST) -> Result<N, ParseError> {
    method name (line 299) | fn name(&self) -> &str {
    type Modifier (line 307) | type Modifier = R::Modifier;
    method parse_once (line 309) | fn parse_once(&mut self, ast: &AST) -> Result<Self::Modifier, ParseErr...
    method name (line 319) | fn name(&self) -> &str {
  type Item (line 196) | type Item = ParseErrorF;
  method get_source (line 198) | fn get_source(&self) -> SourceOffset {
  method get_value (line 202) | fn get_value(&self) -> &ParseErrorF {
  function new (line 224) | pub fn new(symbol_value: &str, result: M) -> Constant<M> {
  function new (line 251) | pub fn new(values: Vec<Box<dyn ParseRule<Modifier=M> + 'a>>) -> Several<...
  function named (line 256) | pub fn named(mut self, name: &str) -> Self {

FILE: src/ir/modifier/var.rs
  type VarMod (line 27) | pub enum VarMod {
    method apply (line 34) | pub fn apply(&self, decl: &mut ClassVarDecl) {
  function parser (line 44) | pub fn parser() -> impl ParseRule<Modifier=VarMod> {

FILE: src/ir/modifier/visibility.rs
  function parser (line 28) | pub fn parser() -> impl ParseRule<Modifier=Visibility> {

FILE: src/ir/quasiquote.rs
  type QQSpliced (line 33) | enum QQSpliced {
    method into_single (line 75) | fn into_single(self, ast: &AST) -> Result<Expr, GDError> {
  type UnquotedValue (line 52) | enum UnquotedValue<'a> {
  function verbatim (line 88) | fn verbatim(arg: &'a AST) -> UnquotedValue<'a> {
  function parse (line 112) | fn parse(arg: &'a AST) -> UnquotedValue<'a> {
  function quasiquote (line 133) | pub fn quasiquote(icompiler: &mut IncCompiler,
  function quasiquote_with_depth (line 140) | pub fn quasiquote_with_depth(icompiler: &mut IncCompiler,
  type QuasiquoteEngine (line 158) | struct QuasiquoteEngine<'a, 'b> {
  function new (line 175) | fn new(icompiler: &'a mut IncCompiler, pipeline: &'b mut Pipeline, max_d...
  function quasiquote_indexed (line 186) | fn quasiquote_indexed(&mut self,
  function quasiquote_spliced (line 210) | fn quasiquote_spliced(&mut self,

FILE: src/ir/scope/decl.rs
  type ClassNamespaceAdaptor (line 46) | pub struct ClassNamespaceAdaptor<'a, T>(pub &'a T);
  type DeclScope (line 53) | pub trait DeclScope<NS: Hash + Eq + Clone> {
    method get_scope_names (line 57) | fn get_scope_names(&self) -> Result<NameTable<NS>, ScopeError<NS>>;
  function get_scope_names (line 64) | fn get_scope_names(&self) -> Result<NameTable<ClassNamespace>, ScopeErro...
  method get_scope_names (line 80) | fn get_scope_names(&self) -> Result<NameTable<Namespace>, ScopeError<Nam...
  method get_scope_names (line 94) | fn get_scope_names(&self) -> Result<NameTable<ClassNamespace>, ScopeErro...
  method get_scope_names (line 115) | fn get_scope_names(&self) -> Result<NameTable<ClassNamespace>, ScopeErro...
  function get_scope_names (line 136) | fn get_scope_names(&self) -> Result<NameTable<NS>, ScopeError<NS>> {
  function get_all_decl_scopes (line 150) | pub fn get_all_decl_scopes<'a>(toplevel: &'a TopLevel) -> Vec<Box<dyn De...
  function check_all_decl_scopes (line 181) | pub fn check_all_decl_scopes(toplevel: &TopLevel) -> Result<(), ScopeErr...
  function on_each_lambda_class (line 190) | pub fn on_each_lambda_class<E, F>(decls: &[Decl], mut block: F) -> Resul...

FILE: src/ir/scope/error.rs
  type ScopeError (line 30) | pub enum ScopeError<NS> {
  function from (line 38) | fn from(error: ScopeError<Namespace>) -> ScopeError<ClassNamespace> {

FILE: src/ir/scope/mod.rs
  type ConcreteNamesAdaptor (line 33) | struct ConcreteNamesAdaptor<'a>(&'a TopLevel);
  function check_scopes (line 37) | pub fn check_scopes(toplevel: &TopLevel) -> Result<(),  GDError> {
  function check_main_class_conflicts (line 48) | pub fn check_main_class_conflicts(toplevel: &TopLevel) -> Result<(), GDE...
  function get_scope_names (line 81) | fn get_scope_names(&self) -> Result<NameTable<Namespace>, ScopeError<Nam...
  function is_declare_decl (line 95) | fn is_declare_decl(decl: &Decl) -> bool {

FILE: src/ir/scope/name_table/builder.rs
  type NameTableBuilder (line 30) | pub struct NameTableBuilder<NS: Hash + Eq + Clone> {
  function new (line 37) | pub fn new() -> NameTableBuilder<NS> {
  function add_name (line 46) | pub fn add_name(&mut self, namespace: NS, name: String, pos: SourceOffse...
  function build (line 66) | pub fn build(self) -> NameTable<NS> {
  method default (line 73) | fn default() -> NameTableBuilder<NS> {

FILE: src/ir/scope/name_table/mod.rs
  type NameTable (line 33) | pub struct NameTable<NS: Hash + Eq + Clone> {
  function new (line 40) | pub fn new() -> NameTable<NS> {
  function get_name (line 46) | pub fn get_name(&self, namespace: NS, name: &str) -> Option<SourceOffset> {
  function has_name (line 54) | pub fn has_name(&self, namespace: NS, name: &str) -> bool {
  function add_name (line 63) | pub fn add_name(&mut self, namespace: NS, name: String, pos: SourceOffse...
  function len (line 68) | pub fn len(&self) -> usize {
  function is_empty (line 73) | pub fn is_empty(&self) -> bool {
  function map_ns (line 87) | pub fn map_ns<NS1: Hash + Eq + Clone>(self, mut function: impl FnMut(NS)...
  function retain (line 95) | pub fn retain<F>(&mut self, mut f: F)
  function iter (line 100) | pub fn iter(&self) -> impl Iterator<Item=(NS, &str, SourceOffset)> {
  method default (line 108) | fn default() -> NameTable<NS> {
  function empty_table (line 120) | fn empty_table() {
  function table_insert_names (line 126) | fn table_insert_names() {
  function table_crossed_namespaces (line 136) | fn table_crossed_namespaces() {
  function table_duplicate_name_different_namespace (line 146) | fn table_duplicate_name_different_namespace() {
  function table_duplicate_name_same_namespace (line 154) | fn table_duplicate_name_same_namespace() {
  function table_map_ns (line 162) | fn table_map_ns() {
  function table_map_ns_collision (line 178) | fn table_map_ns_collision() {

FILE: src/ir/special_form/access_slot.rs
  type AccessSlotSyntax (line 27) | pub struct AccessSlotSyntax<'a> {
  constant ACCESS_SLOT_FORM_NAME (line 32) | pub const ACCESS_SLOT_FORM_NAME: &str = "access-slot";
  function parse_ast (line 36) | pub fn parse_ast(ast: &'a AST) -> Result<Self, GDError> {
  function parse_from_tail (line 48) | pub fn parse_from_tail(tail: &[&'a AST], pos: SourceOffset) -> Result<Se...

FILE: src/ir/special_form/assignment.rs
  type AssignmentForm (line 24) | pub enum AssignmentForm {
    method str_to_setter_prefix (line 31) | pub fn str_to_setter_prefix(name: &str) -> String {
    method into_expr (line 35) | pub fn into_expr(self, rhs: Expr, pos: SourceOffset) -> Expr {

FILE: src/ir/special_form/local_binding.rs
  type FLetLocalBinding (line 29) | pub struct FLetLocalBinding;
  type LabelsLocalBinding (line 30) | pub struct LabelsLocalBinding;
  type LocalBinding (line 32) | pub trait LocalBinding {
    method function_binding_type (line 33) | fn function_binding_type(&self) -> FunctionBindingType;
    method has_recursive_bindings (line 34) | fn has_recursive_bindings(&self) -> bool;
    method wrap_in_expr (line 36) | fn wrap_in_expr(&self, clauses: Vec<LocalFnClause>, body: Box<Expr>, p...
    method function_binding_type (line 43) | fn function_binding_type(&self) -> FunctionBindingType {
    method has_recursive_bindings (line 46) | fn has_recursive_bindings(&self) -> bool {
    method function_binding_type (line 52) | fn function_binding_type(&self) -> FunctionBindingType {
    method has_recursive_bindings (line 55) | fn has_recursive_bindings(&self) -> bool {

FILE: src/ir/special_form/mod.rs
  function dispatch_form (line 47) | pub fn dispatch_form(icompiler: &mut IncCompiler,
  function progn_form (line 87) | pub fn progn_form(icompiler: &mut IncCompiler,
  function cond_form (line 96) | pub fn cond_form(icompiler: &mut IncCompiler,
  function while_form (line 122) | pub fn while_form(icompiler: &mut IncCompiler,
  function for_form (line 133) | pub fn for_form(icompiler: &mut IncCompiler,
  function let_form (line 145) | pub fn let_form(icompiler: &mut IncCompiler,
  function lambda_form (line 173) | pub fn lambda_form(icompiler: &mut IncCompiler,
  function function_form (line 185) | pub fn function_form(tail: &[&AST],
  function assign_form (line 193) | pub fn assign_form(icompiler: &mut IncCompiler,
  function flet_form (line 222) | pub fn flet_form(icompiler: &mut IncCompiler,
  function quote_form (line 276) | pub fn quote_form(tail: &[&AST], pos: SourceOffset) -> Result<Expr, PErr...
  function quasiquote_form (line 281) | pub fn quasiquote_form(icompiler: &mut IncCompiler,
  function access_slot_form (line 290) | pub fn access_slot_form(icompiler: &mut IncCompiler,
  function new_form (line 300) | pub fn new_form(icompiler: &mut IncCompiler,
  function yield_form (line 327) | pub fn yield_form(icompiler: &mut IncCompiler,
  function assert_form (line 362) | pub fn assert_form(icompiler: &mut IncCompiler,
  function return_form (line 384) | pub fn return_form(icompiler: &mut IncCompiler,
  function macrolet_form (line 394) | pub fn macrolet_form(icompiler: &mut IncCompiler,
  function symbol_macrolet_form (line 424) | pub fn symbol_macrolet_form(icompiler: &mut IncCompiler,
  function special_ref_form (line 452) | pub fn special_ref_form(_icompiler: &mut IncCompiler,
  function context_filename_form (line 491) | pub fn context_filename_form(_icompiler: &mut IncCompiler,
  function literally_form (line 505) | pub fn literally_form(tail: &[&AST], pos: SourceOffset) -> Result<Expr, ...
  function split_form (line 511) | pub fn split_form(icompiler: &mut IncCompiler,
  function macrolet_bind_locals (line 521) | fn macrolet_bind_locals<B, E, F, I>(icompiler: &mut IncCompiler,
  function macrolet_unbind_macros (line 565) | fn macrolet_unbind_macros<'a, B, E, F, I>(icompiler: &mut IncCompiler,
  function preload_form (line 601) | pub fn preload_form(_icompiler: &mut IncCompiler,
  function bootstrap_form (line 611) | pub fn bootstrap_form(icompiler: &mut IncCompiler,
  function break_form (line 621) | pub fn break_form(_icompiler: &mut IncCompiler,
  function continue_form (line 630) | pub fn continue_form(_icompiler: &mut IncCompiler,

FILE: src/ir/special_ref.rs
  type SpecialRef (line 34) | pub enum SpecialRef {
  method from (line 56) | fn from(special_ref: SpecialRef) -> ExprF {

FILE: src/main.rs
  function run_pseudo_repl (line 49) | fn run_pseudo_repl(godot_version: VersionInfo) {
  function run_repl (line 74) | fn run_repl(godot_version: VersionInfo) {
  function compile_file (line 123) | fn compile_file<P : AsRef<Path> + ?Sized>(input: &P, godot_version: Vers...
  function compile_all_files (line 135) | fn compile_all_files<P : AsRef<Path> + ?Sized>(input: &P, godot_version:...
  function main (line 153) | fn main() {

FILE: src/optimize/gdscript/assignment.rs
  type AssignmentStmt (line 23) | pub struct AssignmentStmt<'a> {
  type AssignType (line 30) | pub enum AssignType {
    method ensure_eq (line 59) | pub fn ensure_eq(self) -> Self {
  function match_stmt (line 37) | pub fn match_stmt(stmt: &'a Stmt) -> Option<AssignmentStmt<'a>> {
  method from (line 70) | fn from(stmt: AssignmentStmt) -> Stmt {

FILE: src/optimize/gdscript/basic_math_ops.rs
  type BasicMathOps (line 24) | pub struct BasicMathOps;
  method run_on_expr (line 27) | fn run_on_expr(&self, expr: &Expr) -> Result<Expr, GDError> {

FILE: src/optimize/gdscript/constant.rs
  function deduce_bool (line 25) | pub fn deduce_bool(expr: &Expr) -> Option<bool> {
  function stmt_has_side_effects (line 45) | pub fn stmt_has_side_effects(stmt: &Stmt) -> bool {
  function expr_has_side_effects (line 58) | pub fn expr_has_side_effects(expr: &Expr) -> bool {
  function expr_is_constant (line 84) | pub fn expr_is_constant(expr: &Expr) -> bool {
  function e (line 107) | fn e(expr: ExprF) -> Expr {
  function literals_as_bool_test (line 112) | fn literals_as_bool_test() {
  function arbitrary_expr_as_bool_test (line 126) | fn arbitrary_expr_as_bool_test() {

FILE: src/optimize/gdscript/constant_conditional_branch.rs
  type ConstantConditionalBranch (line 24) | pub struct ConstantConditionalBranch;
    method run_on_stmt_acc (line 44) | pub fn run_on_stmt_acc(&self, stmts: &[Stmt]) -> Result<Vec<Stmt>, GDE...
  function kill_if_branch (line 27) | fn kill_if_branch(if_stmt: &stmt::IfStmt, pos: SourceOffset) -> Vec<Stmt> {
  method run_on_stmt (line 56) | fn run_on_stmt(&self, stmt: &Stmt) -> Result<Vec<Stmt>, GDError> {

FILE: src/optimize/gdscript/dead_code_elimination.rs
  type DeadCodeElimination (line 23) | pub struct DeadCodeElimination;
  method run_on_stmt (line 28) | fn run_on_stmt(&self, stmt: &Stmt) -> Result<Vec<Stmt>, GDError> {
  function e (line 60) | fn e(expr: ExprF) -> Expr {
  function s (line 64) | fn s(stmt: StmtF) -> Stmt {
  function else_do_not_run_on_stmt (line 69) | fn else_do_not_run_on_stmt() {
  function else_run_on_stmt (line 84) | fn else_run_on_stmt() {

FILE: src/optimize/gdscript/dead_decl_elimination.rs
  type DeadDeclElimination (line 27) | pub struct DeadDeclElimination;
  method run_on_file (line 34) | fn run_on_file(&self, file: &mut decl::TopLevelClass) -> Result<(), GDEr...
  function d (line 55) | fn d(decl: DeclF) -> Decl {
  function eliminate_pass (line 60) | fn eliminate_pass() {

FILE: src/optimize/gdscript/dead_var_elimination.rs
  type DeadVarElimination (line 25) | pub struct DeadVarElimination;
    method run_on_body (line 28) | fn run_on_body(&self, stmts: &mut Vec<Stmt>) {
  method run_on_function (line 47) | fn run_on_function(&self, function: &mut decl::FnDecl) -> Result<(), GDE...
  method run_on_init_function (line 51) | fn run_on_init_function(&self, function: &mut decl::InitFnDecl) -> Resul...

FILE: src/optimize/gdscript/direct_var_substitute.rs
  type DirectVarSubstitute (line 27) | pub struct DirectVarSubstitute;
    method run_on_body (line 36) | fn run_on_body(&self, stmts: &mut Vec<Stmt>) {
  method run_on_function (line 57) | fn run_on_function(&self, function: &mut decl::FnDecl) -> Result<(), GDE...
  method run_on_init_function (line 61) | fn run_on_init_function(&self, function: &mut decl::InitFnDecl) -> Resul...

FILE: src/optimize/gdscript/else_then_if_fold.rs
  type ElseThenIfFold (line 22) | pub struct ElseThenIfFold;
  method run_on_stmt (line 25) | fn run_on_stmt(&self, stmt: &Stmt) -> Result<Vec<Stmt>, GDError> {
  function e (line 55) | fn e(expr: ExprF) -> Expr {
  function s (line 59) | fn s(stmt: StmtF) -> Stmt {
  function else_then_if_optimize_test (line 64) | fn else_then_if_optimize_test() {

FILE: src/optimize/gdscript/expr_walker.rs
  function walk_expr (line 25) | pub fn walk_expr<'a, E>(stmt: &Stmt, mut walker: impl FnMut(&Expr) -> Re...
  function walk_exprs (line 30) | pub fn walk_exprs<'a, E>(stmts: &[Stmt], mut walker: impl FnMut(&Expr) -...
  function walk_expr_ok (line 35) | pub fn walk_expr_ok<'a>(stmt: &Stmt, mut walker: impl FnMut(&Expr) -> Ex...
  function walk_exprs_ok (line 41) | pub fn walk_exprs_ok<'a>(stmts: &[Stmt], mut walker: impl FnMut(&Expr) -...
  function walk_impl_expr (line 47) | fn walk_impl_expr<'a, E>(walker: &mut (impl FnMut(&Expr) -> Result<Expr,...
  function walk_impl (line 99) | fn walk_impl<'a, E>(walker: &mut (impl FnMut(&Expr) -> Result<Expr, E> +...

FILE: src/optimize/gdscript/mod.rs
  type ExpressionLevelPass (line 44) | pub trait ExpressionLevelPass {
    method run_on_expr (line 45) | fn run_on_expr(&self, expr: &Expr) -> Result<Expr, GDError>;
  type StatementLevelPass (line 48) | pub trait StatementLevelPass {
    method run_on_stmt (line 49) | fn run_on_stmt(&self, stmt: &Stmt) -> Result<Vec<Stmt>, GDError>;
    method run_on_stmt (line 141) | fn run_on_stmt(&self, stmt: &Stmt) -> Result<Vec<Stmt>, GDError> {
  type FunctionOptimization (line 52) | pub trait FunctionOptimization {
    method run_on_function (line 53) | fn run_on_function(&self, function: &mut decl::FnDecl) -> Result<(), G...
    method run_on_init_function (line 54) | fn run_on_init_function(&self, function: &mut decl::InitFnDecl) -> Res...
    method run_on_function (line 129) | fn run_on_function(&self, function: &mut decl::FnDecl) -> Result<(), G...
    method run_on_init_function (line 133) | fn run_on_init_function(&self, function: &mut decl::InitFnDecl) -> Res...
  type FileOptimization (line 57) | pub trait FileOptimization {
    method run_on_file (line 58) | fn run_on_file(&self, file: &mut decl::TopLevelClass) -> Result<(), GD...
    method run_on_file (line 121) | fn run_on_file(&self, file: &mut decl::TopLevelClass) -> Result<(), GD...
  function on_each_decl_impl (line 64) | fn on_each_decl_impl(decls: &[Decl], acc: &mut Vec<Decl>, block: &mut im...
  function on_each_decl (line 94) | pub fn on_each_decl(decls: &[Decl], mut block: impl FnMut(&Decl) -> Resu...
  function on_decl (line 100) | fn on_decl(opt: &impl FunctionOptimization, decl: &Decl) -> Result<Vec<D...
  function run_standard_passes (line 147) | pub fn run_standard_passes(file: &mut decl::TopLevelClass) -> Result<(),...

FILE: src/optimize/gdscript/noop.rs
  function is_code_seq_noop (line 24) | pub fn is_code_seq_noop(stmts: &[Stmt]) -> bool {
  function is_code_noop (line 28) | pub fn is_code_noop(stmt: &Stmt) -> bool {
  function is_expr_noop (line 32) | pub fn is_expr_noop(expr: &Expr) -> bool {
  function e (line 44) | fn e(expr: ExprF) -> Expr {
  function s (line 48) | fn s(stmt: StmtF) -> Stmt {
  function expr_noop (line 53) | fn expr_noop() {
  function stmt_noop (line 71) | fn stmt_noop() {

FILE: src/optimize/gdscript/redundant_assignment_elimination.rs
  type RedundantAssignmentElimination (line 28) | pub struct RedundantAssignmentElimination;
    method match_first_assign (line 48) | fn match_first_assign<'a>(&self, stmt: &'a Stmt) -> Option<AssignmentS...
    method match_second_assign (line 56) | fn match_second_assign<'a, 'b, 'c>(&'a self, name: &'b str, stmt: &'c ...
    method rebuild_assignment (line 65) | fn rebuild_assignment(&self, assign_type: AssignType, var_name: &str, ...
    method run_on_stmts (line 69) | pub fn run_on_stmts(&self, stmts: &[Stmt]) -> Result<Vec<Stmt>, GDErro...
  method run_on_function (line 99) | fn run_on_function(&self, function: &mut decl::FnDecl) -> Result<(), GDE...
  method run_on_init_function (line 103) | fn run_on_init_function(&self, function: &mut decl::InitFnDecl) -> Resul...
  function e (line 117) | fn e(expr: ExprF) -> Expr {
  function s (line 121) | fn s(stmt: StmtF) -> Stmt {
  function redundant_assign_test_1 (line 126) | fn redundant_assign_test_1() {
  function redundant_assign_test_2 (line 158) | fn redundant_assign_test_2() {
  function redundant_assign_test_3 (line 192) | fn redundant_assign_test_3() {
  function redundant_assign_test_4 (line 222) | fn redundant_assign_test_4() {
  function redundant_assign_test_no_trigger_1 (line 252) | fn redundant_assign_test_no_trigger_1() {
  function redundant_assign_test_no_trigger_2 (line 276) | fn redundant_assign_test_no_trigger_2() {
  function redundant_assign_test_no_trigger_3 (line 298) | fn redundant_assign_test_no_trigger_3() {
  function redundant_assign_test_no_trigger_4 (line 320) | fn redundant_assign_test_no_trigger_4() {

FILE: src/optimize/gdscript/stmt_walker.rs
  type StmtWalker (line 29) | struct StmtWalker<'a, E> {
  type WalkFn (line 33) | type WalkFn<'a, E> = dyn FnMut(&[Stmt]) -> Result<Vec<Stmt>, E> + 'a;
  function new (line 37) | fn new(function: impl FnMut(&[Stmt]) -> Result<Vec<Stmt>, E> + 'a) -> St...
  function walk_stmts (line 41) | fn walk_stmts(&mut self, stmts: &[Stmt]) -> Result<Vec<Stmt>, E> {
  function walk_stmt (line 49) | fn walk_stmt(&mut self, stmt: &Stmt) -> Result<Vec<Stmt>, E> {
  function on_each_stmt (line 90) | pub fn on_each_stmt<'a, E>(mut walker: impl FnMut(&Stmt) -> Result<Vec<S...
  function on_each_stmt_ok (line 102) | pub fn on_each_stmt_ok<'a>(mut walker: impl FnMut(&Stmt) -> Vec<Stmt> + 'a)
  function walk_stmt (line 116) | pub fn walk_stmt<'a, E>(stmt: &Stmt, walker: impl FnMut(&[Stmt]) -> Resu...
  function walk_stmts (line 126) | pub fn walk_stmts<'a, E>(stmts: &[Stmt], walker: impl FnMut(&[Stmt]) -> ...
  function walk_stmt_ok (line 133) | pub fn walk_stmt_ok<'a>(stmt: &Stmt, mut walker: impl FnMut(&[Stmt]) -> ...
  function walk_stmts_ok (line 140) | pub fn walk_stmts_ok<'a>(stmts: &[Stmt], mut walker: impl FnMut(&[Stmt])...
  type SampleError (line 155) | struct SampleError;
  function s (line 157) | fn s(stmt: StmtF) -> Stmt {
  function e (line 161) | fn e(expr: ExprF) -> Expr {
  function test_walk_simple_stmt (line 166) | fn test_walk_simple_stmt() {
  function test_walk_simple_stmt_seq (line 174) | fn test_walk_simple_stmt_seq() {
  function test_walk_complex_stmt (line 182) | fn test_walk_complex_stmt() {
  function test_walk_complex_stmt_seq (line 194) | fn test_walk_complex_stmt_seq() {
  function test_walk_simple_error_1 (line 207) | fn test_walk_simple_error_1() {
  function test_walk_simple_error_2 (line 214) | fn test_walk_simple_error_2() {

FILE: src/optimize/gdscript/ternary_if_fold.rs
  type TernaryIfFold (line 24) | pub struct TernaryIfFold;
    method fold_into_ternary (line 43) | fn fold_into_ternary(acc: Expr, next: (Expr, Expr)) -> Expr {
    method match_simple_assign (line 55) | fn match_simple_assign<'a>(&self, stmts: &'a [Stmt]) -> Option<(&'a st...
    method try_to_run (line 64) | fn try_to_run(&self, if_stmt: &stmt::IfStmt) -> Option<Stmt> {
  method run_on_stmt (line 100) | fn run_on_stmt(&self, stmt: &Stmt) -> Result<Vec<Stmt>, GDError> {
  function e (line 115) | fn e(expr: ExprF) -> Expr {
  function s (line 119) | fn s(stmt: StmtF) -> Stmt {
  function ternary_if_fold_test_1 (line 124) | fn ternary_if_fold_test_1() {
  function ternary_if_fold_test_2 (line 149) | fn ternary_if_fold_test_2() {
  function ternary_if_fold_test_no_trigger_1 (line 180) | fn ternary_if_fold_test_no_trigger_1() {
  function ternary_if_fold_test_no_trigger_2 (line 198) | fn ternary_if_fold_test_no_trigger_2() {

FILE: src/optimize/gdscript/variables.rs
  type VarInfo (line 28) | pub struct VarInfo {
    method new (line 36) | pub fn new(expr: Expr) -> VarInfo {
    method is_ever_used (line 40) | pub fn is_ever_used(&self) -> bool {
    method is_read_only (line 44) | pub fn is_read_only(&self) -> bool {
  function get_variable_info (line 50) | pub fn get_variable_info(stmts: &[Stmt]) -> HashMap<String, VarInfo> {

FILE: src/optimize/ir/expr_walker.rs
  type ExprWalker (line 24) | struct ExprWalker<'a, E> {
  type WalkFn (line 28) | type WalkFn<'a, E> = dyn (FnMut(&Expr) -> Result<Expr, E>) + 'a;
  function new (line 32) | fn new(function: impl FnMut(&Expr) -> Result<Expr, E> + 'a) -> ExprWalke...
  function walk_exprs (line 36) | fn walk_exprs(&mut self, exprs: &[Expr]) -> Result<Vec<Expr>, E> {
  function walk_expr (line 42) | fn walk_expr(&mut self, expr: &Expr) -> Result<Expr, E> {
  function walk_lambda_class (line 196) | fn walk_lambda_class(&mut self, cls: &expr::LambdaClass) -> Result<expr:...
  function walk_expr (line 233) | pub fn walk_expr<'a, E>(expr: &Expr, walker: impl FnMut(&Expr) -> Result...
  function walk_expr_ok (line 239) | pub fn walk_expr_ok<'a>(expr: &Expr, mut walker: impl FnMut(&Expr) -> Ex...
  function walk_exprs_in_decl (line 245) | pub fn walk_exprs_in_decl<'a, E>(decl: &Decl, walker: impl FnMut(&Expr) ...
  function walk_exprs_in_toplevel (line 336) | pub fn walk_exprs_in_toplevel<'a, E>(decl: &decl::TopLevel, mut walker: ...
  function walk_exprs_in_toplevel_ok (line 345) | pub fn walk_exprs_in_toplevel_ok<'a>(decl: &decl::TopLevel, mut walker: ...

FILE: src/optimize/ir/mod.rs
  type FileOptimization (line 23) | pub trait FileOptimization {
    method run_on_file (line 24) | fn run_on_file(&self, file: &mut TopLevel) -> Result<(), GDError>;

FILE: src/parser_test.rs
  function so (line 26) | fn so(x: usize) -> SourceOffset {
  function parser_simple (line 32) | fn parser_simple() {
  function parser_simple_unicode (line 42) | fn parser_simple_unicode() {
  function parser_string (line 57) | fn parser_string() {
  function parser_list (line 65) | fn parser_list() {
  function parser_quoting (line 74) | fn parser_quoting() {
  function parser_colon (line 82) | fn parser_colon() {
  function parser_at_self (line 91) | fn parser_at_self() {
  function parser_comments (line 98) | fn parser_comments() {
  function parser_array (line 109) | fn parser_array() {
  function parser_dict (line 117) | fn parser_dict() {
  function parser_failures (line 125) | fn parser_failures() {

FILE: src/pipeline/can_load.rs
  type CanLoad (line 34) | pub trait CanLoad {
    method current_filename_option (line 38) | fn current_filename_option(&self) -> Option<RPathBuf>;
    method current_filename (line 50) | fn current_filename(&self) -> RPathBuf {
    method current_filename_option (line 57) | fn current_filename_option(&self) -> Option<RPathBuf> {

FILE: src/pipeline/config.rs
  type ProjectConfig (line 28) | pub struct ProjectConfig {

FILE: src/pipeline/error.rs
  type PError (line 35) | pub enum PError {
    method fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method eq (line 133) | fn eq(&self, other: &PError) -> bool {
    method from (line 147) | fn from(e: ParseError<L, T, E>) -> PError {
    method from (line 153) | fn from(e: IOError) -> PError {
    method from (line 159) | fn from(e: GDError) -> PError {
    method from (line 165) | fn from(e: TryFromDottedExprError) -> PError {
    method from (line 171) | fn from(e: ArgListParseError) -> PError {
    method from (line 177) | fn from(e: ModifierParseError) -> PError {
    method from (line 183) | fn from(e: DuplicateMainClassError) -> PError {
    method from (line 190) | fn from(e: ScopeError<NS>) -> PError {
    method from (line 196) | fn from(e: LoopPrimitiveError) -> PError {
    method from (line 202) | fn from(e: DependencyError) -> PError {
  type IOError (line 43) | pub struct IOError {
    method fmt (line 103) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 110) | pub fn new(error: io::Error, pos: SourceOffset) -> IOError {
  type Item (line 54) | type Item = PError;
  method get_source (line 56) | fn get_source(&self) -> SourceOffset {
  method get_value (line 64) | fn get_value(&self) -> &PError {
  method source (line 72) | fn source(&self) -> Option<&(dyn Error + 'static)> {
  function get_source_from_parse_error (line 82) | fn get_source_from_parse_error<T, E>(err: &ParseError<SourceOffset, T, E...
  function from (line 117) | fn from(err: IOError) -> io::Error {
  function _impl_partial_eq_warning (line 122) | fn _impl_partial_eq_warning(err: PError) {

FILE: src/pipeline/loader.rs
  type NullFileLoader (line 24) | pub struct NullFileLoader;
  type NullFileLoaderError (line 26) | pub struct NullFileLoaderError;
  type FileLoader (line 28) | pub trait FileLoader {
    method load_file (line 31) | fn load_file<'a, 'b, P>(&'a mut self, input_path: &'b P)
    method get_file (line 35) | fn get_file<'a, 'b, P>(&'a self, input_path: &'b P) -> Option<&'a Tran...
    type Error (line 42) | type Error = NullFileLoaderError;
    method load_file (line 44) | fn load_file<'a, 'b, P>(&'a mut self, _input_path: &'b P)
    method get_file (line 50) | fn get_file<'a, 'b, P>(&'a self, _input_path: &'b P) -> Option<&'a Tra...

FILE: src/pipeline/mod.rs
  type Pipeline (line 58) | pub struct Pipeline {
    method with_resolver (line 79) | pub fn with_resolver(config: ProjectConfig, resolver: Box<dyn NameReso...
    method new (line 91) | pub fn new(config: ProjectConfig) -> Pipeline {
    method get_native_classes_impl (line 95) | fn get_native_classes_impl() -> NativeClasses {
    method compile_code (line 100) | pub fn compile_code<P : AsRef<Path> + ?Sized>(&mut self, filename: &P,...
    method load_file_unconditionally (line 130) | fn load_file_unconditionally<'a, 'b, P>(&'a mut self, input_path: &'b P)
    method get_loaded_file (line 186) | pub fn get_loaded_file<'a, 'b, P>(&'a self, input_path: &'b P, pos: So...
    method to_absolute_path (line 196) | fn to_absolute_path<P>(&self, input_path: &P) -> PathBuf
    method load_file (line 206) | pub fn load_file<'a, 'b, P>(&'a mut self, input_path: &'b P, pos: Sour...
    method get_file (line 221) | pub fn get_file<'a, 'b, P>(&'a self, input_path: &'b P, pos: SourceOff...
    method get_server (line 226) | pub fn get_server(&self) -> &NamedFileServer {
    method get_server_mut (line 230) | pub fn get_server_mut(&mut self) -> &mut NamedFileServer {
    method make_preload_resolver (line 234) | pub fn make_preload_resolver(&self) -> LookupPreloadResolver {
    method currently_loading_file (line 238) | pub fn currently_loading_file(&self) -> Option<&RPathBuf> {
    method set_currently_loading_file (line 245) | pub fn set_currently_loading_file(&mut self, path: RPathBuf) {
    method config (line 249) | pub fn config(&self) -> &ProjectConfig {
    method get_native_classes (line 253) | pub fn get_native_classes(&mut self) -> &NativeClasses {
  type KnownFile (line 69) | enum KnownFile {
  function input_to_output_filename (line 259) | pub fn input_to_output_filename<P : AsRef<Path> + ?Sized>(input: &P) -> ...

FILE: src/pipeline/resolver.rs
  type DefaultNameResolver (line 33) | pub struct DefaultNameResolver;
  type PanickingNameResolver (line 41) | pub struct PanickingNameResolver;
  type NameResolver (line 61) | pub trait NameResolver {
    method resolve_input_path (line 64) | fn resolve_input_path(&self, filename: &Path) -> io::Result<Box<dyn Re...
    method resolve_output_path (line 67) | fn resolve_output_path(&self, filename: &Path) -> io::Result<Box<dyn W...
    method resolve_input_path (line 72) | fn resolve_input_path(&self, filename: &Path) -> io::Result<Box<dyn Re...
    method resolve_output_path (line 77) | fn resolve_output_path(&self, filename: &Path) -> io::Result<Box<dyn W...
    method resolve_input_path (line 86) | fn resolve_input_path(&self, _filename: &Path) -> io::Result<Box<dyn R...
    method resolve_output_path (line 90) | fn resolve_output_path(&self, _filename: &Path) -> io::Result<Box<dyn ...

FILE: src/pipeline/source.rs
  type SourceOffset (line 35) | pub struct SourceOffset(pub usize);
    method from (line 180) | fn from(x: usize) -> SourceOffset {
    method fmt (line 192) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type SourcePos (line 41) | pub struct SourcePos {
    method new (line 146) | pub fn new(line: usize, column: usize) -> SourcePos {
    method from_offset (line 152) | pub fn from_offset(offset: SourceOffset, source: &str) -> SourcePos {
    method fmt (line 198) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type SourcedValue (line 50) | pub struct SourcedValue<'a, T: Sourced> {
  type Sourced (line 64) | pub trait Sourced {
    method get_source (line 70) | fn get_source(&self) -> SourceOffset;
    method get_value (line 73) | fn get_value(&self) -> &Self::Item;
    type Item (line 106) | type Item = T::Item;
    method get_source (line 108) | fn get_source(&self) -> SourceOffset {
    method get_value (line 112) | fn get_value(&self) -> &Self::Item {
  function new (line 82) | pub fn new(value: &'a T, source_code: &str) -> SourcedValue<'a, T> {
  function from_file (line 92) | pub fn from_file<P>(value: &'a T, source_file: &P) -> io::Result<Sourced...
  function get_source_pos (line 99) | pub fn get_source_pos(&self) -> SourcePos {
  function find_newlines (line 123) | pub fn find_newlines(source: &str) -> Vec<SourceOffset> {
  function from (line 186) | fn from(x: SourceOffset) -> usize {
  function fmt (line 204) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function test_newlines (line 214) | fn test_newlines() {
  function test_offset (line 241) | fn test_offset() {

FILE: src/pipeline/stdlib_unit.rs
  type StdlibUnit (line 33) | pub struct StdlibUnit {
    method from (line 44) | fn from(unit: TranslationUnit) -> StdlibUnit {

FILE: src/pipeline/translation_unit.rs
  type TranslationUnit (line 38) | pub struct TranslationUnit {
    method new (line 71) | pub fn new(filename: PathBuf,
    method clone_detached (line 97) | pub fn clone_detached(&self) -> TranslationUnit {
  method from (line 112) | fn from(trans: TranslationUnit) -> TopLevelClass {

FILE: src/repl.rs
  type Repl (line 59) | pub struct Repl {
    constant REPL_FILENAME (line 70) | const REPL_FILENAME: &'static str =
    method new (line 73) | pub fn new(config: ProjectConfig) -> Repl {
    method with_pipeline (line 77) | pub fn with_pipeline(pipeline: Pipeline) -> Repl {
    method initialize (line 86) | fn initialize(&mut self) {
    method force_load (line 102) | pub fn force_load(&mut self) {
    method run_code (line 129) | pub fn run_code(&mut self, code: &AST) -> Result<String, PError> {
    method parse_and_run_code (line 190) | pub fn parse_and_run_code(&mut self, code: &str) -> Result<String, PEr...
    method is_running (line 203) | pub fn is_running(&mut self) -> bool {
    method remember_symbols (line 207) | fn remember_symbols(&mut self, filename: &Path, table: &mut SymbolTabl...
    method bind_existing_names (line 226) | fn bind_existing_names(&self, table: &mut SymbolTable) {
    method main_function_handler (line 230) | fn main_function_handler() -> StaticMainFunctionHandler {
  function dummy_config (line 244) | fn dummy_config() -> ProjectConfig {
  function basic_repl_test (line 253) | fn basic_repl_test() {
  function quoted_repl_test (line 259) | fn quoted_repl_test() {
  function array_repl_test (line 265) | fn array_repl_test() {
  function dict_repl_test (line 271) | fn dict_repl_test() {
  function decl_then_expr_in_one_repl_command_test (line 277) | fn decl_then_expr_in_one_repl_command_test() {
  function force_load_in_repl_test (line 283) | fn force_load_in_repl_test() {
  function decl_then_expr_in_two_repl_commands_test (line 291) | fn decl_then_expr_in_two_repl_commands_test() {
  function failed_decl_then_expr_repl_test (line 299) | fn failed_decl_then_expr_repl_test() {
  function failed_repl_continues_test (line 309) | fn failed_repl_continues_test() {
  function minimalist_at_repl_test (line 319) | fn minimalist_at_repl_test() {
  function terminate_repl_via_tree_test (line 327) | fn terminate_repl_via_tree_test() {
  function terminate_repl_via_quit_test (line 336) | fn terminate_repl_via_quit_test() {

FILE: src/runner/godot.rs
  type GodotCommand (line 33) | pub struct GodotCommand {
    method raw (line 50) | pub fn raw() -> Self {
    method base (line 63) | pub fn base() -> Self {
    method arg (line 75) | pub fn arg(&mut self, arg_text: impl AsRef<OsStr>) -> &mut Self {
    method no_window (line 85) | pub fn no_window(&mut self) -> &mut Self {
    method script_file (line 91) | pub fn script_file(&mut self, filename: &Path) -> &mut Self {
    method project_dir (line 101) | pub fn project_dir(&mut self, directory_name: &Path) -> &mut Self {
    method quit_after_one (line 107) | pub fn quit_after_one(&mut self) -> &mut Self {
    method quiet (line 112) | pub fn quiet(&mut self) -> &mut Self {
    method env (line 120) | pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Self
    method envs (line 131) | pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Self
    method stderr (line 142) | pub fn stderr(&mut self, cfg: impl Into<Stdio>) -> &mut Self {
    method stdout (line 150) | pub fn stdout(&mut self, cfg: impl Into<Stdio>) -> &mut Self {
    method stdin (line 158) | pub fn stdin(&mut self, cfg: impl Into<Stdio>) -> &mut Self {
    method output (line 167) | pub fn output(&mut self) -> io::Result<Output> {
    method status (line 175) | pub fn status(&mut self) -> io::Result<ExitStatus> {
    method spawn (line 183) | pub fn spawn(&mut self) -> io::Result<Child> {
  method from (line 190) | fn from(godot_command: GodotCommand) -> Command {

FILE: src/runner/into_gd_file.rs
  type IntoGDFile (line 31) | pub trait IntoGDFile {
    method write_to_gd (line 33) | fn write_to_gd(&self, file: &mut impl Write) -> io::Result<()>;
    method write_to_gd (line 39) | fn write_to_gd(&self, file: &mut impl Write) -> io::Result<()> {
    method write_to_gd (line 47) | fn write_to_gd(&self, file: &mut impl Write) -> io::Result<()> {

FILE: src/runner/macro_server/command.rs
  type ServerCommand (line 36) | pub enum ServerCommand {
    method name (line 47) | pub fn name(&self) -> &'static str {
    method arguments (line 58) | pub fn arguments(&self) -> Vec<&str> {
    method to_json (line 76) | pub fn to_json(&self) -> JsonValue {

FILE: src/runner/macro_server/lazy.rs
  type LazyServer (line 41) | pub struct LazyServer(Option<MacroServer>);
    method new (line 51) | pub fn new() -> LazyServer {
    method is_running (line 56) | pub fn is_running(&self) -> bool {
    method get_mut (line 71) | pub fn get_mut(&mut self) -> io::Result<&mut MacroServer> {
    method get_mut_if_initialized (line 84) | pub fn get_mut_if_initialized(&mut self) -> Option<&mut MacroServer> {
    method shutdown (line 98) | pub fn shutdown(self) -> io::Result<Option<ExitStatus>> {

FILE: src/runner/macro_server/mod.rs
  constant DEFAULT_PORT_NUMBER (line 53) | pub const DEFAULT_PORT_NUMBER: u16 = 61992;
  type MacroServer (line 63) | pub struct MacroServer {
    method new (line 74) | pub fn new() -> io::Result<MacroServer> {
    method new_on_ports (line 78) | pub fn new_on_ports(min_port: u16, max_port: u16) -> io::Result<MacroS...
    method lock_macro_server_init (line 104) | fn lock_macro_server_init() -> io::Result<MutexGuard<'static, ()>> {
    method try_to_bind_port (line 110) | fn try_to_bind_port(start: u16, end: u16) -> io::Result<(TcpListener, ...
    method send_string (line 128) | fn send_string(&mut self, string: &str) -> io::Result<()> {
    method receive_string (line 137) | fn receive_string(&mut self) -> io::Result<String> {
    method issue_command (line 149) | pub fn issue_command(&mut self, command: &ServerCommand) -> io::Result...
    method _shutdown (line 160) | fn _shutdown(&mut self) -> io::Result<ExitStatus> {
    method shutdown (line 169) | pub fn shutdown(self) -> io::Result<ExitStatus> {
    method is_process_healthy (line 177) | pub fn is_process_healthy(&mut self) -> bool {
  method drop (line 201) | fn drop(&mut self) {
  function run_godot_child_process (line 207) | fn run_godot_child_process(port: u16) -> io::Result<Child> {
  function issue_command_and_unwrap (line 227) | fn issue_command_and_unwrap(server: &mut MacroServer, value: &ServerComm...
  function roundtrip_value (line 232) | fn roundtrip_value(server: &mut MacroServer, value: &str) {
  function spawn_server_simple_test (line 239) | fn spawn_server_simple_test() {
  function spawn_server_ping_pong_test (line 244) | fn spawn_server_ping_pong_test() {
  function spawn_server_eval_test (line 252) | fn spawn_server_eval_test() {
  function spawn_server_roundtrip_test_1 (line 259) | fn spawn_server_roundtrip_test_1() {
  function spawn_server_roundtrip_test_2 (line 271) | fn spawn_server_roundtrip_test_2() {
  function spawn_server_roundtrip_test_3 (line 284) | fn spawn_server_roundtrip_test_3() {
  function spawn_server_load_test (line 298) | fn spawn_server_load_test() {
  function spawn_server_exec_test (line 308) | fn spawn_server_exec_test() {
  function spawn_server_bad_json_test (line 316) | fn spawn_server_bad_json_test() {
  function healthy_server_test (line 332) | fn healthy_server_test() {
  function unhealthy_server_test (line 339) | fn unhealthy_server_test() {

FILE: src/runner/macro_server/named_file_server.rs
  type NamedFileServer (line 70) | pub struct NamedFileServer {
    method new (line 106) | pub fn new() -> NamedFileServer {
    method add_reserved_macro (line 129) | pub fn add_reserved_macro(&mut self, name: String) -> MacroID {
    method load_file_on_server (line 141) | fn load_file_on_server(&mut self, path: &Path) -> io::Result<u32> {
    method stand_up_file (line 159) | pub fn stand_up_file(&mut self, file: NamedTempFile) -> io::Result<()> {
    method stand_up_macro (line 175) | pub fn stand_up_macro(&mut self, name: String, file: NamedTempFile) ->...
    method get_file (line 185) | fn get_file(&self, id: MacroID) -> Option<&MacroCall> {
    method run_server_file (line 207) | pub fn run_server_file(&mut self, id: MacroID, prelude: Vec<Stmt>, spe...
    method run_server_file_str (line 215) | pub fn run_server_file_str(&mut self, id: MacroID, prelude: Vec<Stmt>,...
    method do_macro_call (line 253) | fn do_macro_call(&mut self,
    method set_global_name_generator (line 271) | pub fn set_global_name_generator(&mut self, gen: &FreshNameGenerator) ...
    method reset_global_name_generator (line 282) | pub fn reset_global_name_generator(&mut self) -> io::Result<()> {
    method is_process_healthy (line 294) | pub fn is_process_healthy(&mut self) -> bool {
  type MacroID (line 81) | pub struct MacroID(u32);
    constant RESERVED (line 312) | const RESERVED: u32 = 1024;
    method smallest_stdlib (line 314) | fn smallest_stdlib() -> MacroID {
    method smallest_unreserved (line 318) | fn smallest_unreserved() -> MacroID {
    method is_reserved (line 322) | fn is_reserved(self) -> bool {
    method next (line 326) | fn next(self) -> MacroID {
  type MacroCall (line 84) | struct MacroCall {
  constant RESERVED_MACRO_INDEX (line 93) | const RESERVED_MACRO_INDEX: u32 = u32::MAX;
  function response_to_string (line 96) | fn response_to_string(response: response::ServerResponse) -> io::Result<...

FILE: src/runner/macro_server/response.rs
  type ServerResponse (line 33) | pub enum ServerResponse {
    type Error (line 103) | type Error = ParseError;
    method try_from (line 105) | fn try_from(json: JsonValue) -> Result<ServerResponse, ParseError> {
  type Failure (line 41) | pub struct Failure {
    method fmt (line 139) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Success (line 53) | pub struct Success {
    type Error (line 71) | type Error = Failure;
    method try_from (line 73) | fn try_from(resp: ServerResponse) -> Result<Success, Failure> {
  type ParseError (line 62) | pub enum ParseError {
    method fmt (line 129) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fail (line 66) | fn fail(json: &JsonValue) -> ParseError {
  type Error (line 83) | type Error = Failure;
  method try_from (line 85) | fn try_from(resp: ServerResponse) -> Result<String, Failure> {

FILE: src/runner/mod.rs
  type JsonApiError (line 43) | pub struct JsonApiError;
    method fmt (line 46) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function dump_json_api (line 57) | pub fn dump_json_api() -> io::Result<NamedTempFile> {
  function make_tmp_file (line 73) | fn make_tmp_file() -> io::Result<NamedTempFile> {
  function run_with_temporary (line 87) | fn run_with_temporary(data: &str) -> io::Result<String> {
  function run_minimal_test (line 102) | fn run_minimal_test() {
  function run_printing_test (line 112) | fn run_printing_test() {
  function dump_json_api_test (line 123) | fn dump_json_api_test() {

FILE: src/runner/named_file.rs
  type NamedFile (line 30) | pub trait NamedFile : io::Write {
    method path (line 33) | fn path(&self) -> &Path;
    method path (line 68) | fn path(&self) -> &Path {
    method path (line 74) | fn path(&self) -> &Path {
  type SimpleNamedFile (line 41) | pub struct SimpleNamedFile(PathBuf, File);
    method create (line 48) | pub fn create<P : AsRef<Path>>(path: P) -> io::Result<SimpleNamedFile> {
    method write (line 57) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    method flush (line 61) | fn flush(&mut self) -> io::Result<()> {

FILE: src/runner/path.rs
  type RPathBuf (line 50) | pub struct RPathBuf {
    method new (line 86) | pub fn new(source: PathSrc, path: PathBuf) -> Result<RPathBuf, TryFrom...
    method source (line 97) | pub fn source(&self) -> PathSrc {
    method path (line 102) | pub fn path(&self) -> &Path {
    method path_mut (line 111) | pub fn path_mut(&mut self) -> &mut PathBuf {
    method into_path (line 116) | pub fn into_path(self) -> PathBuf {
    method components (line 122) | pub fn components(&self) -> Components<'_> {
    method extension (line 128) | pub fn extension(&self) -> Option<&OsStr> {
    method components_no_root (line 135) | pub fn components_no_root(&self) -> Components<'_> {
    method path_to_string (line 147) | pub fn path_to_string<P : AsRef<Path> + ?Sized>(path: &P) -> String {
    method fmt (line 157) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Error (line 193) | type Error = TryFromRPathBufError;
    method try_from (line 195) | fn try_from(path: String) -> Result<RPathBuf, TryFromRPathBufError> {
  type PathSrc (line 58) | pub enum PathSrc {
    method should_be_relative_path (line 170) | pub fn should_be_relative_path(self) -> bool {
    method prefix (line 179) | pub fn prefix(self) -> &'static str {
  type TryFromRPathBufError (line 69) | pub enum TryFromRPathBufError {
  function test_rpathbuf_new_relative (line 213) | fn test_rpathbuf_new_relative() {
  function test_rpathbuf_new_absolute_windows (line 221) | fn test_rpathbuf_new_absolute_windows() {
  function test_rpathbuf_new_absolute_unix (line 229) | fn test_rpathbuf_new_absolute_unix() {
  function test_rpathbuf_parse (line 236) | fn test_rpathbuf_parse() {
  function test_rpath_parse_windows (line 254) | fn test_rpath_parse_windows() {
  function test_rpath_parse_unix (line 265) | fn test_rpath_parse_unix() {
  function test_rpathbuf_display (line 275) | fn test_rpathbuf_display() {
  function test_rpathbuf_display_windows (line 282) | fn test_rpathbuf_display_windows() {
  function test_rpathbuf_display_unix (line 288) | fn test_rpathbuf_display_unix() {

FILE: src/runner/version.rs
  type Version (line 27) | pub struct Version {
    method new (line 45) | pub fn new(major: i32, minor: i32, patch: i32) -> Self {
    method into_i32 (line 54) | pub fn into_i32(self) -> i32 {
  type VersionInfo (line 36) | pub struct VersionInfo {
    method new (line 64) | pub fn new() -> Self {
    method parse (line 72) | pub fn parse(version_string: &str) -> VersionInfo {
  function get_godot_version_as_string (line 102) | pub fn get_godot_version_as_string() -> io::Result<String> {
  function get_godot_version (line 116) | pub fn get_godot_version() -> io::Result<VersionInfo> {
  function pop_version_number (line 121) | fn pop_version_number(atoms: &mut VecDeque<&str>) -> Option<i32> {
  function test_parse_basic_version_string (line 133) | fn test_parse_basic_version_string() {
  function test_parse_nonsense_version_string (line 169) | fn test_parse_nonsense_version_string() {
  function test_parse_full_version_string (line 182) | fn test_parse_full_version_string() {
  function test_parse_partial_version_string (line 200) | fn test_parse_partial_version_string() {

FILE: src/sxp/ast.rs
  type ASTF (line 31) | pub enum ASTF {
    constant NIL (line 73) | pub const NIL: ASTF = ASTF::Atom(Literal::Nil);
    method cons (line 77) | pub fn cons(car: AST, cdr: AST) -> ASTF {
    method string (line 83) | pub fn string<S>(s: S) -> ASTF
    method symbol (line 90) | pub fn symbol<S>(s: S) -> ASTF
    method int (line 96) | pub fn int(value: i32) -> ASTF {
    method float (line 101) | pub fn float(value: f32) -> ASTF {
    method from (line 376) | fn from(_: ()) -> ASTF {
    method from (line 382) | fn from(n: i32) -> ASTF {
    method from (line 388) | fn from(b: bool) -> ASTF {
    method from (line 394) | fn from(f: f32) -> ASTF {
    method from (line 400) | fn from(s: String) -> ASTF {
    method from (line 406) | fn from(s: &'a str) -> ASTF {
  type AST (line 44) | pub struct AST {
    method new (line 111) | pub fn new(value: ASTF, pos: SourceOffset) -> AST {
    method nil (line 117) | pub fn nil(pos: SourceOffset) -> AST {
    method symbol (line 122) | pub fn symbol<S>(name: S, pos: SourceOffset) -> AST
    method string (line 128) | pub fn string<S>(name: S, pos: SourceOffset) -> AST
    method int (line 134) | pub fn int(value: i32, pos: SourceOffset) -> AST {
    method float (line 139) | pub fn float(value: f32, pos: SourceOffset) -> AST {
    method cons (line 144) | pub fn cons(car: AST, cdr: AST, pos: SourceOffset) -> AST {
    method _recurse (line 148) | fn _recurse<'a, 'b, F1, F2, E>(&'a self, func: &mut F1, default: &mut ...
    method _recurse_mut (line 164) | fn _recurse_mut<'a, 'b, F1, F2, E>(&'a mut self, func: &mut F1, defaul...
    method _walk_preorder (line 180) | fn _walk_preorder<'a, 'b, F, E>(&'a self, func: &mut F) -> Result<(), E>
    method _walk_preorder_mut (line 187) | fn _walk_preorder_mut<'a, F, E>(&'a mut self, func: &mut F) -> Result<...
    method _walk_postorder (line 193) | fn _walk_postorder<'a, 'b, F, E>(&'a self, func: &mut F) -> Result<(), E>
    method _walk_postorder_mut (line 200) | fn _walk_postorder_mut<'a, F, E>(&'a mut self, func: &mut F) -> Result...
    method walk_preorder (line 213) | pub fn walk_preorder<'a, 'b, F, E>(&'a self, mut func: F) -> Result<()...
    method walk_preorder_mut (line 220) | pub fn walk_preorder_mut<'a, F, E>(&'a mut self, mut func: F) -> Resul...
    method walk_postorder (line 232) | pub fn walk_postorder<'a, 'b, F, E>(&'a self, mut func: F) -> Result<(...
    method walk_postorder_mut (line 239) | pub fn walk_postorder_mut<'a, F, E>(&'a mut self, mut func: F) -> Resu...
    method each_source_mut (line 247) | pub fn each_source_mut<F>(&mut self, mut func: F)
    method each_source (line 257) | pub fn each_source<F>(&self, func: F) -> AST
    method all_symbols (line 269) | pub fn all_symbols<'a>(&'a self) -> Vec<&'a str> {
    method dotted_list (line 300) | pub fn dotted_list(vec: Vec<AST>, terminal: AST) -> AST {
    method dotted_list_fold (line 304) | fn dotted_list_fold(cdr: AST, car: AST) -> AST { // NOTE: Arguments re...
    method list (line 310) | pub fn list(vec: Vec<AST>, nil_pos: SourceOffset) -> AST {
    method from_value (line 315) | pub fn from_value<T>(value: T, pos: SourceOffset) -> AST
    method as_symbol_ref (line 323) | pub fn as_symbol_ref(&self) -> Option<&str> {
    method fmt (line 338) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt_list (line 49) | fn fmt_list(a: &AST, b: &AST, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 352) | type Item = ASTF;
  method get_source (line 354) | fn get_source(&self) -> SourceOffset {
  method get_value (line 358) | fn get_value(&self) -> &ASTF {
  method depth (line 366) | fn depth(&self) -> u32 {
  function int (line 420) | fn int(n: i32) -> AST {
  function nil (line 424) | fn nil() -> AST {
  function cons (line 428) | fn cons(a: AST, b: AST) -> AST {
  function runtime_repr_numerical (line 433) | fn runtime_repr_numerical() {
  function runtime_repr_nil (line 441) | fn runtime_repr_nil() {
  function runtime_repr_string (line 446) | fn runtime_repr_string() {
  function runtime_repr_symbol (line 453) | fn runtime_repr_symbol() {
  function runtime_repr_cons (line 459) | fn runtime_repr_cons() {
  function runtime_repr_list (line 466) | fn runtime_repr_list() {
  function get_all_symbols (line 472) | fn get_all_symbols() {
  function each_source (line 484) | fn each_source() {
  function add10 (line 490) | fn add10(x: SourceOffset) -> SourceOffset {
  function test_depth_atomic (line 495) | fn test_depth_atomic() {
  function test_depth_nested (line 504) | fn test_depth_nested() {

FILE: src/sxp/dotted.rs
  type DottedExpr (line 38) | pub struct DottedExpr<'a> {
  type TryFromDottedExprError (line 47) | pub struct TryFromDottedExprError {
  function accumulate_ast (line 51) | fn accumulate_ast<'a>(vec: &mut Vec<&'a AST>, ast: &'a AST) -> &'a AST {
  function new (line 76) | pub fn new(ast: &'a AST) -> DottedExpr<'a> {
  type Error (line 92) | type Error = TryFromDottedExprError;
  function try_from (line 97) | fn try_from(expr: DottedExpr<'a>) -> Result<Vec<&'a AST>, TryFromDottedE...
  function int (line 112) | fn int(n: i32) -> AST {
  function nil (line 116) | fn nil() -> AST {
  function list (line 120) | fn list(data: Vec<AST>) -> AST {
  function simple_dot (line 125) | fn simple_dot() {
  function proper_list (line 136) | fn proper_list() {
  function improper_list (line 150) | fn improper_list() {

FILE: src/sxp/literal.rs
  type Literal (line 29) | pub enum Literal {
    method fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 67) | fn from(value: i32) -> Literal {
    method from (line 73) | fn from(value: f32) -> Literal {
    method from (line 79) | fn from(value: OrderedFloat<f32>) -> Literal {
    method from (line 85) | fn from(value: String) -> Literal {
    method from (line 91) | fn from(value: &'a str) -> Literal {
    method from (line 97) | fn from(value: bool) -> Literal {

FILE: src/sxp/reify/mod.rs
  type Reify (line 31) | pub trait Reify {
    method reify (line 35) | fn reify(&self) -> Expr;
    method reify (line 41) | fn reify(&self) -> Expr {
  function int (line 56) | fn int(n: i32) -> AST {
  function nil (line 60) | fn nil() -> AST {
  function list (line 65) | fn list(data: Vec<AST>) -> AST {
  function cons (line 69) | fn cons(a: AST, b: AST) -> AST {
  function reify_test (line 74) | fn reify_test() {

FILE: src/sxp/reify/pretty.rs
  function reify_pretty_expr (line 48) | pub fn reify_pretty_expr(value: &AST, max_depth: u32, gen: &mut impl Nam...
  function reify_pretty (line 57) | pub fn reify_pretty<W>(value: &AST, max_depth: u32, gen: &mut impl NameG...
  type PrettyPrinter (line 64) | struct PrettyPrinter<'a, G: NameGenerator> {
  function new (line 72) | fn new(gen: &'a mut G, max_depth: u32) -> Self {
  function reify_pretty_rec (line 76) | fn reify_pretty_rec(&mut self, value: &AST, depth: u32) -> Expr {
  function build (line 97) | fn build(self) -> Vec<Stmt> {
  function reify_literal (line 103) | fn reify_literal(value: &Literal, pos: SourceOffset) -> Expr {
  function cons (line 133) | fn cons(a: AST, b: AST) -> AST {
  function int (line 137) | fn int(n: i32) -> AST {
  function reify_pretty_test_1 (line 142) | fn reify_pretty_test_1() {
  function reify_pretty_test_2 (line 150) | fn reify_pretty_test_2() {
  function reify_pretty_test_3 (line 158) | fn reify_pretty_test_3() {
  function reify_pretty_test_4 (line 167) | fn reify_pretty_test_4() {
  function reify_pretty_test_5 (line 176) | fn reify_pretty_test_5() {
  function reify_pretty_test_6 (line 185) | fn reify_pretty_test_6() {
  function reify_pretty_test_7 (line 201) | fn reify_pretty_test_7() {

FILE: src/sxp/string.rs
  constant ESCAPE_SEQUENCES (line 27) | const ESCAPE_SEQUENCES: phf::Map<char, char> = phf_map! {
  type Error (line 42) | pub enum Error {
  function parse_escapes (line 71) | pub fn parse_escapes(input: &str) -> Result<String, Error> {
  function parse_unicode_sequence (line 105) | fn parse_unicode_sequence(iter: &mut impl Iterator<Item=char>,
  function is_hex_digit (line 147) | fn is_hex_digit(digit: char) -> bool {
  function insert_escapes (line 169) | pub fn insert_escapes(input: &str) -> String {
  function should_escape (line 193) | fn should_escape(ch: char) -> bool {
  function reverse_escape_map (line 197) | fn reverse_escape_map() -> HashMap<char, String> {
  function successful_escaping (line 210) | fn successful_escaping() {
  function failed_escaping (line 219) | fn failed_escaping() {

FILE: src/sxp/syntax.rs
  function unary (line 30) | pub fn unary(head: &str, value: AST, pos: SourceOffset) -> AST {
  function binary (line 40) | pub fn binary(head: &str, b: AST, c: AST, pos: SourceOffset) -> AST {
  function trinary (line 51) | pub fn trinary(head: &str, b: AST, c: AST, d: AST, pos: SourceOffset) ->...
  function quote (line 61) | pub fn quote(value: AST, pos: SourceOffset) -> AST {
  function function (line 66) | pub fn function(value: AST, pos: SourceOffset) -> AST {
  function quasiquote (line 71) | pub fn quasiquote(value: AST, pos: SourceOffset) -> AST {
  function unquote (line 76) | pub fn unquote(value: AST, pos: SourceOffset) -> AST {
  function unquote_spliced (line 81) | pub fn unquote_spliced(value: AST, pos: SourceOffset) -> AST {
  function array (line 87) | pub fn array(tail: AST, pos: SourceOffset) -> AST {
  function dict (line 93) | pub fn dict(tail: AST, pos: SourceOffset) -> AST {
  function vector2 (line 98) | pub fn vector2(x: AST, y: AST, pos: SourceOffset) -> AST {
  function vector3 (line 103) | pub fn vector3(x: AST, y: AST, z: AST, pos: SourceOffset) -> AST {
  function access_slot (line 108) | pub fn access_slot(x: AST, y: AST, pos: SourceOffset) -> AST {
  function get_node_on (line 116) | pub fn get_node_on(x: AST, y: AST, pos: SourceOffset) -> AST {
  function test_unary (line 130) | fn test_unary() {
  function test_binary (line 144) | fn test_binary() {
  function test_trinary (line 159) | fn test_trinary() {
  function test_quote (line 175) | fn test_quote() {
  function test_function (line 189) | fn test_function() {
  function test_quasiquote (line 203) | fn test_quasiquote() {
  function test_unquote (line 217) | fn test_unquote() {
  function test_unquote_spliced (line 231) | fn test_unquote_spliced() {

FILE: src/util/debug_wrapper.rs
  type DebugWrapper (line 32) | pub struct DebugWrapper<T>(pub T);
  method fmt (line 36) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: src/util/group_by.rs
  type GroupBy (line 26) | pub struct GroupBy<I: Iterator, F> {
  type Item (line 35) | type Item = Vec<<I as Iterator>::Item>;
  method next (line 37) | fn next(&mut self) -> Option<Self::Item> {
  function group_by (line 82) | pub fn group_by<I, F>(iter: I, function: F) -> GroupBy<I, F>
  function group_with (line 94) | pub fn group_with<I, F, G>(iter: I, mut function: F) -> GroupBy<I, impl ...
  function group_by_test_1 (line 108) | fn group_by_test_1() {
  function group_by_test_2 (line 115) | fn group_by_test_2() {
  function group_by_test_3 (line 122) | fn group_by_test_3() {
  function group_with_test (line 129) | fn group_with_test() {

FILE: src/util/lattice.rs
  type Lattice (line 39) | pub trait Lattice {
    method join (line 43) | fn join(self, other: Self) -> Self;
    method meet (line 47) | fn meet(self, other: Self) -> Self;
    method join (line 53) | fn join(self, _other: ()) -> () {
    method meet (line 56) | fn meet(self, _other: ()) -> () {
    method join (line 63) | fn join(self, other: (A, B)) -> (A, B) {
    method meet (line 66) | fn meet(self, other: (A, B)) -> (A, B) {

FILE: src/util/lazy.rs
  type Lazy (line 23) | pub struct Lazy<T, F> {
  function new (line 36) | pub fn new(init: F) -> Lazy<T, F> {
  function force_mut (line 40) | pub fn force_mut(&mut self) -> &mut T {

FILE: src/util/mod.rs
  function fold1 (line 39) | pub fn fold1<I : Iterator, F : FnMut(I::Item, I::Item) -> I::Item>(iter:...
  type PairIter (line 47) | pub struct PairIter<T, I>(Option<T>, I);
  function each_pair (line 67) | pub fn each_pair<T, I>(iter: I) -> PairIter<T, I> where I : Iterator<Ite...
  type Item (line 72) | type Item = (T, T);
  method next (line 74) | fn next(&mut self) -> Option<(T, T)> {
  type NonOverlappingPairIter (line 84) | pub struct NonOverlappingPairIter<I>(I);
  function each_non_overlapping_pair (line 109) | pub fn each_non_overlapping_pair<I: Iterator>(iter: I) -> NonOverlapping...
  type Item (line 114) | type Item = (<I as Iterator>::Item, <I as Iterator>::Item);
  method next (line 116) | fn next(&mut self) -> Option<Self::Item> {
  function merge_hashmap_inplace (line 131) | pub fn merge_hashmap_inplace<K : Eq + Hash, V>(a: &mut HashMap<K, V>,
  function read_to_end (line 146) | pub fn read_to_end(input: &mut impl Read) -> io::Result<String> {
  function option_to_vec (line 154) | pub fn option_to_vec<T>(value: Option<T>) -> Vec<T> {
  function extract_err (line 164) | pub fn extract_err<T>(value: Result<T, Infallible>) -> T {
  function unzip_err (line 176) | pub fn unzip_err<E, FromA, FromB, I, A, B>(iter: I) -> Result<(FromA, Fr...
  function find_or_else_mut (line 195) | pub fn find_or_else_mut<T>(vec: &mut Vec<T>, default: impl FnOnce() -> T...
  type FakeError (line 209) | struct FakeError;
  function test_fold1 (line 212) | fn test_fold1() {
  function test_extract_err (line 224) | fn test_extract_err() {
  function test_unzip_err_1 (line 229) | fn test_unzip_err_1() {
  function test_unzip_err_2 (line 242) | fn test_unzip_err_2() {
  function find_or_else_mut_1 (line 263) | fn find_or_else_mut_1() {
  function find_or_else_mut_2 (line 274) | fn find_or_else_mut_2() {

FILE: src/util/one.rs
  type One (line 26) | pub struct One<T>(pub T);
  type Iter (line 29) | pub struct Iter<'a, T>(Option<&'a T>);
  type IterMut (line 32) | pub struct IterMut<'a, T>(Option<&'a mut T>);
  type IntoIter (line 36) | pub struct IntoIter<T>(Option<T>);
  function iter (line 40) | pub fn iter(&self) -> Iter<'_, T> {
  function iter_mut (line 44) | pub fn iter_mut(&mut self) -> IterMut<'_, T> {
  method clone (line 52) | fn clone(&self) -> Self {
  type Item (line 58) | type Item = T;
  type IntoIter (line 59) | type IntoIter = IntoIter<T>;
  method into_iter (line 61) | fn into_iter(self) -> IntoIter<T> {
  type Item (line 68) | type Item = &'a T;
  method next (line 70) | fn next(&mut self) -> Option<&'a T> {
  type Item (line 79) | type Item = &'a mut T;
  method next (line 81) | fn next(&mut self) -> Option<&'a mut T> {
  type Item (line 90) | type Item = T;
  method next (line 92) | fn next(&mut self) -> Option<T> {
  function one_iter (line 105) | fn one_iter() {
  function one_iter_mut (line 111) | fn one_iter_mut() {
  function one_into_iter (line 121) | fn one_into_iter() {

FILE: src/util/prefix_matcher.rs
  type PrefixMatcher (line 27) | pub struct PrefixMatcher<'a> {
  type PrefixTable (line 34) | struct PrefixTable<T> {
  function new (line 41) | fn new(width: usize) -> PrefixTable<T> {
  function width (line 45) | fn width(&self) -> usize {
  function height (line 49) | fn height(&self) -> usize {
  function get (line 53) | fn get(&self, y: usize, x: usize) -> Option<&T> {
  function get_mut (line 61) | fn get_mut(&mut self, y: usize, x: usize) -> Option<&mut T> {
  function add_row (line 70) | fn add_row(&mut self, row: impl Iterator<Item=T>) {
  function add_row_value (line 80) | fn add_row_value(&mut self, value: T) {
  function build (line 92) | pub fn build<I, S>(options: I) -> Self
  function build_chars_map (line 123) | fn build_chars_map<S>(options: &[&S]) -> HashMap<char, usize>
  function identify_prefix (line 141) | pub fn identify_prefix(&self, string: &str) -> Option<&'a str> {
  constant EMPTY_CELL (line 171) | const EMPTY_CELL: usize = usize::MAX;
  function test_chars_map (line 178) | fn test_chars_map() {
  function test_empty_prefix_identifier (line 187) | fn test_empty_prefix_identifier() {
  function test_empty_string_prefix_identifier (line 197) | fn test_empty_string_prefix_identifier() {
  function test_prefix_identifier_foobar (line 207) | fn test_prefix_identifier_foobar() {
  function test_prefix_identifier_foobar_with_empty (line 222) | fn test_prefix_identifier_foobar_with_empty() {

FILE: src/util/recursive.rs
  type Recursive (line 24) | pub trait Recursive {
    method depth (line 31) | fn depth(&self) -> u32;

FILE: tests/test/builtin_function_test.rs
  function vector_test (line 26) | pub fn vector_test() {
  function vector_syntax_test (line 32) | pub fn vector_syntax_test() {
  function array_test (line 38) | pub fn array_test() {
  function array_syntax_test (line 44) | pub fn array_syntax_test() {
  function dictionary_test (line 49) | pub fn dictionary_test() {
  function dictionary_odd_args_test (line 54) | pub fn dictionary_odd_args_test() {
  function dictionary_literal_test (line 60) | pub fn dictionary_literal_test() {
  function yield_test (line 65) | pub fn yield_test() {
  function assert_test (line 71) | pub fn assert_test() {
  function attribute_test (line 77) | pub fn attribute_test() {
  function method_test (line 83) | pub fn method_test() {
  function simple_builtin_test (line 89) | pub fn simple_builtin_test() {
  function known_gdscript_classes_test_1 (line 96) | pub fn known_gdscript_classes_test_1() {
  function known_gdscript_classes_test_2 (line 102) | pub fn known_gdscript_classes_test_2() {
  function unknown_gdscript_classes_test (line 108) | pub fn unknown_gdscript_classes_test() {
  function return_test (line 116) | pub fn return_test() {
  function yield_running_test (line 122) | pub fn yield_running_test() {
  function yield_star_running_test (line 140) | pub fn yield_star_running_test() {
  function custom_call_magic_test (line 160) | pub fn custom_call_magic_test() {
  function custom_call_magic_test_failed (line 175) | pub fn custom_call_magic_test_failed() {
  function split_call_test_1 (line 183) | pub fn split_call_test_1() {
  function split_call_test_2 (line 191) | pub fn split_call_test_2() {
  function wrapped_random_functions_test (line 200) | pub fn wrapped_random_functions_test() {
  function wrapped_math_functions_test (line 210) | pub fn wrapped_math_functions_test() {
  function wrapped_error_functions_test (line 252) | pub fn wrapped_error_functions_test() {
  function wrapped_load_functions_test (line 258) | pub fn wrapped_load_functions_test() {
  function failed_preload_function_test (line 263) | pub fn failed_preload_function_test() {
  function wrapped_range_functions_test (line 269) | pub fn wrapped_range_functions_test() {
  function wrapped_misc_functions_test (line 280) | pub fn wrapped_misc_functions_test() {
  function convert_function_test (line 306) | pub fn convert_function_test() {
  function convert_function_run_test (line 312) | pub fn convert_function_run_test() {
  function instance_from_id_function_test (line 318) | pub fn instance_from_id_function_test() {
  function instance_from_id_function_run_test (line 323) | pub fn instance_from_id_function_run_test() {
  function str_test (line 333) | pub fn str_test() {
  function printerr_test (line 339) | pub fn printerr_test() {
  function print_test (line 344) | pub fn print_test() {
  function printt_test (line 349) | pub fn printt_test() {
  function prints_test (line 354) | pub fn prints_test() {
  function printraw_test (line 359) | pub fn printraw_test() {
  function print_debug_test (line 364) | pub fn print_debug_test() {
  function builtin_constant_on_type_test (line 369) | pub fn builtin_constant_on_type_test() {
  function builtin_type_constructor_test (line 374) | pub fn builtin_type_constructor_test() {
  function nodepath_constructor_test (line 416) | pub fn nodepath_constructor_test() {
  function str_running_test (line 425) | pub fn str_running_test() {
  function str_running_test_indirect (line 430) | pub fn str_running_test_indirect() {
  function printerr_running_test (line 435) | pub fn printerr_running_test() {
  function printerr_running_test_indirect (line 442) | pub fn printerr_running_test_indirect() {
  function printraw_running_test (line 449) | pub fn printraw_running_test() {
  function printraw_running_test_indirect (line 454) | pub fn printraw_running_test_indirect() {
  function print_running_test (line 459) | pub fn print_running_test() {
  function range_running_test (line 464) | pub fn range_running_test() {
  function range_running_test_indirect (line 470) | pub fn range_running_test_indirect() {
  function print_running_test_indirect (line 476) | pub fn print_running_test_indirect() {
  function deep_equal_test (line 481) | pub fn deep_equal_test() {
  function cons_accessor_test_1 (line 491) | pub fn cons_accessor_test_1() {
  function cons_accessor_test_2 (line 497) | pub fn cons_accessor_test_2() {
  function cons_accessor_test_3 (line 505) | pub fn cons_accessor_test_3() {
  function nodepath_running_test (line 517) | pub fn nodepath_running_test() {
  function vector_constant_print_test (line 523) | pub fn vector_constant_print_test() {
  function object_constant_value_test (line 528) | pub fn object_constant_value_test() {
  function thread_macro_test (line 541) | pub fn thread_macro_test() {
  function last_thread_macro_test (line 547) | pub fn last_thread_macro_test() {
  function as_thread_macro_test_1 (line 553) | pub fn as_thread_macro_test_1() {
  function as_thread_macro_test_2 (line 559) | pub fn as_thread_macro_test_2() {
  function as_thread_macro_test_3 (line 569) | pub fn as_thread_macro_test_3() {
  function list_is_not_shared_running_test (line 579) | pub fn list_is_not_shared_running_test() {
  function array_find_test (line 590) | pub fn array_find_test() {
  function list_find_test (line 599) | pub fn list_find_test() {
  function dict_find_test (line 608) | pub fn dict_find_test() {
  function vector_map_test (line 618) | pub fn vector_map_test() {
  function vector_map_two_arguments_test (line 626) | pub fn vector_map_two_arguments_test() {
  function array_concat_running_test (line 634) | pub fn array_concat_running_test() {

FILE: tests/test/class_test.rs
  function empty_class_test (line 30) | pub fn empty_class_test() {
  function simple_class_test_1 (line 42) | pub fn simple_class_test_1() {
  function simple_class_test_2 (line 60) | pub fn simple_class_test_2() {
  function parent_constructor_class_test_1 (line 78) | pub fn parent_constructor_class_test_1() {
  function parent_constructor_class_test_2 (line 95) | pub fn parent_constructor_class_test_2() {
  function parent_constructor_class_test_3 (line 112) | pub fn parent_constructor_class_test_3() {
  function parent_constructor_class_test_4 (line 157) | pub fn parent_constructor_class_test_4() {
  function parent_constructor_class_test_5 (line 202) | pub fn parent_constructor_class_test_5() {
  function parent_constructor_class_running_test (line 247) | pub fn parent_constructor_class_running_test() {
  function super_call_in_class_test_1 (line 252) | pub fn super_call_in_class_test_1() {
  function super_call_in_class_test_2 (line 268) | pub fn super_call_in_class_test_2() {
  function super_call_in_class_test_3 (line 287) | pub fn super_call_in_class_test_3() {
  function super_call_in_class_test_4 (line 306) | pub fn super_call_in_class_test_4() {
  function super_call_in_class_test_5 (line 319) | pub fn super_call_in_class_test_5() {
  function super_call_closed_in_class_test_1 (line 335) | pub fn super_call_closed_in_class_test_1() {
  function super_call_closed_in_class_test_2 (line 374) | pub fn super_call_closed_in_class_test_2() {
  function super_call_closed_in_class_test_3 (line 417) | pub fn super_call_closed_in_class_test_3() {
  function member_var_class_test_1 (line 460) | pub fn member_var_class_test_1() {
  function member_var_class_test_2 (line 478) | pub fn member_var_class_test_2() {
  function member_var_class_test_3 (line 496) | pub fn member_var_class_test_3() {
  function member_var_class_test_4 (line 514) | pub fn member_var_class_test_4() {
  function member_var_class_test_5 (line 532) | pub fn member_var_class_test_5() {
  function member_var_class_test_6 (line 550) | pub fn member_var_class_test_6() {
  function member_var_class_test_7 (line 567) | pub fn member_var_class_test_7() {
  function init_member_var_class_test_1 (line 585) | pub fn init_member_var_class_test_1() {
  function init_member_var_class_test_2 (line 602) | pub fn init_member_var_class_test_2() {
  function init_member_var_class_test_3 (line 620) | pub fn init_member_var_class_test_3() {
  function ready_member_var_class_test_1 (line 642) | pub fn ready_member_var_class_test_1() {
  function ready_member_var_class_test_2 (line 656) | pub fn ready_member_var_class_test_2() {
  function complicated_member_var_class_test (line 670) | pub fn complicated_member_var_class_test() {
  function complicated_ready_member_var_class_test (line 698) | pub fn complicated_ready_member_var_class_test() {
  function bad_member_var_class_test_1 (line 729) | pub fn bad_member_var_class_test_1() {
  function bad_self_static_ref_class_test (line 738) | pub fn bad_self_static_ref_class_test() {
  function bad_member_const_class_test (line 747) | pub fn bad_member_const_class_test() {
  function bad_static_constructor_class_test (line 757) | pub fn bad_static_constructor_class_test() {
  function bad_nullargs_constructor_class_test (line 766) | pub fn bad_nullargs_constructor_class_test() {
  function bad_super_in_instance_function_test (line 775) | pub fn bad_super_in_instance_function_test() {
  function signal_class_test_1 (line 784) | pub fn signal_class_test_1() {
  function signal_class_test_2 (line 799) | pub fn signal_class_test_2() {
  function signal_class_test_3 (line 814) | pub fn signal_class_test_3() {
  function signal_class_test_4 (line 829) | pub fn signal_class_test_4() {
  function const_in_class_test (line 845) | pub fn const_in_class_test() {
  function const_in_main_class_test (line 860) | pub fn const_in_main_class_test() {
  function static_in_class_test (line 874) | pub fn static_in_class_test() {
  function nullargs_in_class_test_1 (line 890) | pub fn nullargs_in_class_test_1() {
  function nullargs_in_class_test_2 (line 907) | pub fn nullargs_in_class_test_2() {
  function nullargs_in_class_test_3 (line 923) | pub fn nullargs_in_class_test_3() {
  function nullargs_in_class_test_4 (line 939) | pub fn nullargs_in_class_test_4() {
  function static_in_main_class_test (line 955) | pub fn static_in_main_class_test() {
  function simple_self_closure_class_test (line 970) | pub fn simple_self_closure_class_test() {
  function labels_self_closure_class_test (line 1006) | pub fn labels_self_closure_class_test() {
  function labels_self_closure_class_with_contrived_const_test (line 1034) | pub fn labels_self_closure_class_with_contrived_const_test() {
  function simple_self_run_class_test_1 (line 1065) | pub fn simple_self_run_class_test_1() {
  function simple_self_run_class_test_2 (line 1081) | pub fn simple_self_run_class_test_2() {
  function simple_self_run_class_test_3 (line 1097) | pub fn simple_self_run_class_test_3() {
  function self_with_closure_run_class_test (line 1114) | pub fn self_with_closure_run_class_test() {
  function macro_in_class_test_1 (line 1131) | pub fn macro_in_class_test_1() {
  function macro_in_class_test_2 (line 1160) | pub fn macro_in_class_test_2() {
  function macro_in_class_test_3 (line 1174) | pub fn macro_in_class_test_3() {
  function macro_uses_class_test (line 1187) | pub fn macro_uses_class_test() {
  function reference_static_test_1 (line 1200) | pub fn reference_static_test_1() {
  function reference_static_test_2 (line 1222) | pub fn reference_static_test_2() {
  function reference_static_test_3 (line 1241) | pub fn reference_static_test_3() {
  function reference_static_test_4 (line 1261) | pub fn reference_static_test_4() {
  function main_class_test_1 (line 1280) | pub fn main_class_test_1() {
  function main_class_test_2 (line 1291) | pub fn main_class_test_2() {
  function main_class_test_3 (line 1306) | pub fn main_class_test_3() {
  function main_class_test_4 (line 1325) | pub fn main_class_test_4() {
  function macro_uses_main_class_test (line 1336) | pub fn macro_uses_main_class_test() {
  function reference_to_const_in_class_test (line 1349) | pub fn reference_to_const_in_class_test() {
  function reference_to_static_in_class_test (line 1359) | pub fn reference_to_static_in_class_test() {
  function reference_to_outer_in_class_test_1 (line 1369) | pub fn reference_to_outer_in_class_test_1() {
  function reference_to_outer_in_class_test_2 (line 1379) | pub fn reference_to_outer_in_class_test_2() {
  function reference_to_outer_in_class_test_3 (line 1390) | pub fn reference_to_outer_in_class_test_3() {
  function reference_to_outer_in_class_test_4 (line 1400) | pub fn reference_to_outer_in_class_test_4() {
  function constructor_with_parent_class_test_1 (line 1411) | pub fn constructor_with_parent_class_test_1() {
  function constructor_with_parent_class_test_2 (line 1420) | pub fn constructor_with_parent_class_test_2() {
  function constructor_with_parent_class_test_3 (line 1430) | pub fn constructor_with_parent_class_test_3() {
  function constructor_with_parent_class_test_4 (line 1441) | pub fn constructor_with_parent_class_test_4() {
  function constructor_with_parent_class_test_5 (line 1452) | pub fn constructor_with_parent_class_test_5() {
  function get_node_on_self_class_test (line 1463) | pub fn get_node_on_self_class_test() {
  function get_node_on_explicit_target_class_test (line 1480) | pub fn get_node_on_explicit_target_class_test() {
  function nonsense_modifier_class_test_1 (line 1497) | pub fn nonsense_modifier_class_test_1() {
  function nonsense_modifier_class_test_2 (line 1505) | pub fn nonsense_modifier_class_test_2() {
  function nonsense_modifier_class_test_3 (line 1513) | pub fn nonsense_modifier_class_test_3() {
  function nonsense_modifier_class_test_4 (line 1521) | pub fn nonsense_modifier_class_test_4() {
  function duplicate_main_class_test (line 1529) | pub fn duplicate_main_class_test() {
  function no_self_in_scope_test (line 1537) | pub fn no_self_in_scope_test() {
  function duplicate_constructor_test (line 1545) | pub fn duplicate_constructor_test() {
  function class_setget_test_1 (line 1553) | pub fn class_setget_test_1() {
  function class_setget_test_2 (line 1569) | pub fn class_setget_test_2() {
  function class_setget_test_3 (line 1591) | pub fn class_setget_test_3() {
  function class_setget_test_4 (line 1613) | pub fn class_setget_test_4() {
  function class_setget_test_5 (line 1636) | pub fn class_setget_test_5() {
  function class_setget_test_6 (line 1660) | pub fn class_setget_test_6() {
  function class_setget_test_7 (line 1684) | pub fn class_setget_test_7() {
  function class_setget_test_8 (line 1707) | pub fn class_setget_test_8() {
  function class_setget_conflict_test_1 (line 1730) | pub fn class_setget_conflict_test_1() {
  function class_setget_conflict_test_2 (line 1738) | pub fn class_setget_conflict_test_2() {
  function class_setget_conflict_test_3 (line 1746) | pub fn class_setget_conflict_test_3() {
  function class_setget_conflict_test_4 (line 1754) | pub fn class_setget_conflict_test_4() {
  function class_setget_bad_signature_1 (line 1762) | pub fn class_setget_bad_signature_1() {
  function class_setget_bad_signature_2 (line 1769) | pub fn class_setget_bad_signature_2() {
  function class_setget_bad_signature_3 (line 1776) | pub fn class_setget_bad_signature_3() {
  function class_setget_bad_signature_4 (line 1783) | pub fn class_setget_bad_signature_4() {
  function class_setget_runner_test_1 (line 1790) | pub fn class_setget_runner_test_1() {
  function class_setget_runner_test_2 (line 1804) | pub fn class_setget_runner_test_2() {
  function super_call_runner_test_1 (line 1818) | pub fn super_call_runner_test_1() {
  function super_call_runner_test_2 (line 1834) | pub fn super_call_runner_test_2() {
  function super_call_runner_test_3 (line 1851) | pub fn super_call_runner_test_3() {
  function bad_super_call_test (line 1870) | pub fn bad_super_call_test() {
  function builtin_patched_class_test (line 1878) | pub fn builtin_patched_class_test() {
  function builtin_singleton_class_test (line 1887) | pub fn builtin_singleton_class_test() {
  function lambdas_inside_class_and_out_test (line 1893) | pub fn lambdas_inside_class_and_out_test() {
  function lambdas_inside_class_static_and_out_test (line 1951) | pub fn lambdas_inside_class_static_and_out_test() {

FILE: tests/test/collection_conversion_test.rs
  function array_roundtrip_test (line 21) | fn array_roundtrip_test() {
  function array_list_length_test (line 33) | fn array_list_length_test() {
  function list_array_length_test (line 38) | fn list_array_length_test() {
  function array_varargs_test_1 (line 43) | fn array_varargs_test_1() {
  function array_varargs_test_2 (line 49) | fn array_varargs_test_2() {

FILE: tests/test/common/import.rs
  type StringReader (line 30) | struct StringReader {
    method new (line 54) | pub fn new(s: String) -> StringReader {
  type MockFileLoader (line 36) | pub struct MockFileLoader {
    method new (line 42) | pub fn new() -> MockFileLoader {
    method add_file (line 46) | pub fn add_file(&mut self, name: &str, contents: &str) {
  method read (line 61) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method resolve_input_path (line 72) | fn resolve_input_path(&self, filename: &Path) -> io::Result<Box<dyn Read...
  method resolve_output_path (line 78) | fn resolve_output_path(&self, _filename: &Path) -> io::Result<Box<dyn Wr...

FILE: tests/test/common/mod.rs
  constant TEST_FUNCTION_NAME (line 59) | pub const TEST_FUNCTION_NAME: &'static str = "run_test";
  constant BEGIN_GDLISP_TESTS (line 61) | pub const BEGIN_GDLISP_TESTS: &'static str = "__BEGIN_GDLISP_TESTS__";
  type StringOutput (line 65) | pub struct StringOutput {
  function main_function_handler (line 102) | fn main_function_handler() -> StaticMainFunctionHandler {
  function dummy_config (line 106) | pub fn dummy_config() -> ProjectConfig {
  function dummy_pipeline (line 114) | pub fn dummy_pipeline() -> Pipeline {
  function bind_helper_symbols (line 121) | fn bind_helper_symbols(_table: &mut SymbolTable) {
  function dump_files (line 125) | pub fn dump_files<T>(dir: &mut TempDir, data: &T) -> io::Result<()>
  function parse_and_run_err_impl (line 176) | fn parse_and_run_err_impl(input: &str, runner: &mut GodotCommand) -> Res...
  function strip_cr (line 199) | fn strip_cr(input: &str) -> String {
  function parse_and_run_err (line 205) | pub fn parse_and_run_err(input: &str) -> Result<String, PError> {
  function parse_and_run (line 215) | pub fn parse_and_run(input: &str) -> String {
  function parse_and_run_with_stderr_err (line 219) | pub fn parse_and_run_with_stderr_err(input: &str) -> Result<StringOutput...
  function parse_and_run_with_stderr (line 236) | pub fn parse_and_run_with_stderr(input: &str) -> StringOutput {
  function bind_helper_symbols_comp (line 240) | fn bind_helper_symbols_comp(table: &mut SymbolTable) {
  function parse_compile_and_output_err (line 251) | pub fn parse_compile_and_output_err(input: &str) -> Result<String, PErro...
  function parse_compile_and_output_err_h (line 255) | pub fn parse_compile_and_output_err_h(input: &str) -> Result<(String, St...
  function output_decls (line 284) | fn output_decls(decls: Vec<decl::Decl>) -> String {
  function parse_compile_and_output (line 291) | pub fn parse_compile_and_output(input: &str) -> String {
  function parse_compile_and_output_h (line 295) | pub fn parse_compile_and_output_h(input: &str) -> (String, String) {
  function parse_compile_decl_err (line 299) | pub fn parse_compile_decl_err(input: &str) -> Result<String, PError> {
  function parse_compile_decl (line 317) | pub fn parse_compile_decl(input: &str) -> String {

FILE: tests/test/concurrency_test.rs
  function concurrent_runs_test (line 25) | fn concurrent_runs_test() {

FILE: tests/test/cond_if_test.rs
  function if_tests_expr (line 21) | pub fn if_tests_expr() {
  function if_tests_stmt (line 29) | pub fn if_tests_stmt() {
  function cond_tests_expr (line 35) | pub fn cond_tests_expr() {
  function cond_tests_stmt (line 40) | pub fn cond_tests_stmt() {
  function cond_tests_abbr_expr (line 45) | pub fn cond_tests_abbr_expr() {
  function cond_tests_abbr_stmt (line 50) | pub fn cond_tests_abbr_stmt() {
  function or_test (line 55) | pub fn or_test() {
  function and_test (line 75) | pub fn and_test() {
  function when_test (line 93) | pub fn when_test() {
  function unless_test (line 106) | pub fn unless_test() {
  function if_test_1 (line 122) | fn if_test_1() {
  function if_test_2 (line 131) | fn if_test_2() {

FILE: tests/test/const_test.rs
  function const_test (line 25) | pub fn const_test() {
  function const_test_nonconst (line 39) | pub fn const_test_nonconst() {
  function const_test_nonconst_in_class (line 47) | pub fn const_test_nonconst_in_class() {
  function const_test_nonconst_in_enum (line 55) | pub fn const_test_nonconst_in_enum() {
  function const_test_run (line 63) | pub fn const_test_run() {
  function builtin_const_test (line 71) | pub fn builtin_const_test() {
  function builtin_type_const_test (line 99) | pub fn builtin_type_const_test() {

FILE: tests/test/declaration_test.rs
  function empty_file_test (line 29) | pub fn empty_file_test() {
  function simple_function_declaration_test (line 41) | pub fn simple_function_declaration_test() {
  function lambda_in_function_declaration_test (line 52) | pub fn lambda_in_function_declaration_test() {
  function closed_rw_in_function_declaration_test (line 82) | pub fn closed_rw_in_function_declaration_test() {
  function mutually_recursive_test (line 114) | pub fn mutually_recursive_test() {
  function nonexistent_function_test (line 128) | pub fn nonexistent_function_test() {
  function progn_decl_test (line 136) | pub fn progn_decl_test() {
  function declare_value_test_1 (line 150) | pub fn declare_value_test_1() {
  function declare_value_test_2 (line 160) | pub fn declare_value_test_2() {
  function declare_value_test_3 (line 170) | pub fn declare_value_test_3() {
  function declare_value_test_4 (line 179) | pub fn declare_value_test_4() {
  function declare_value_non_const_test (line 188) | pub fn declare_value_non_const_test() {
  function declare_function_test_1 (line 196) | pub fn declare_function_test_1() {
  function declare_function_test_2 (line 206) | pub fn declare_function

[
  {
    "path": ".github/workflows/style-clippy.yml",
    "chars": 475,
    "preview": "name: Clippy Style Checker\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]\n\nenv:\n  CARGO_"
  },
  {
    "path": ".github/workflows/style-docs.yml",
    "chars": 289,
    "preview": "name: Rustdoc Generation\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]\n\nenv:\n  CARGO_TE"
  },
  {
    "path": ".github/workflows/test-Godotv3.3.3-Ubuntu.yml",
    "chars": 838,
    "preview": "name: \"Ubuntu 20.04 (Godot v3.3.3)\"\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]\n\nenv:"
  },
  {
    "path": ".github/workflows/test-Godotv3.4-Ubuntu.yml",
    "chars": 828,
    "preview": "name: \"Ubuntu 20.04 (Godot v3.4)\"\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]\n\nenv:\n "
  },
  {
    "path": ".github/workflows/test-Godotv3.5-Minimal-Ubuntu.yml",
    "chars": 854,
    "preview": "name: \"Ubuntu 20.04 (Godot v3.5 Minimal)\"\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]"
  },
  {
    "path": ".github/workflows/test-Godotv3.5-Mono-Ubuntu.yml",
    "chars": 952,
    "preview": "name: \"Ubuntu 20.04 (Godot v3.5 Mono)\"\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]\n\ne"
  },
  {
    "path": ".github/workflows/test-Godotv3.5-Ubuntu.yml",
    "chars": 828,
    "preview": "name: \"Ubuntu 20.04 (Godot v3.5)\"\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]\n\nenv:\n "
  },
  {
    "path": ".gitignore",
    "chars": 156,
    "preview": "/target\n/bin\n*~\nGDLisp.gd\nGDLisp.msgpack\n# Generated file that is always identical to /GDLisp.gd\n/MacroServer/GDLisp.gd\n"
  },
  {
    "path": ".readthedocs.yaml",
    "chars": 187,
    "preview": "\nversion: 2\n\nbuild:\n  os: ubuntu-20.04\n  tools:\n    python: \"3.9\"\n\nsphinx:\n  configuration: doc/readthedocs/conf.py\n\npyt"
  },
  {
    "path": "COPYING",
    "chars": 35149,
    "preview": "                    GNU GENERAL PUBLIC LICENSE\n                       Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
  },
  {
    "path": "Cargo.toml",
    "chars": 635,
    "preview": "[package]\nname = \"gdlisp\"\nversion = \"1.0.0\"\nauthors = [\"Silvio Mayolo <mercerenies@gmail.com>\"]\nedition = \"2018\"\nbuild ="
  },
  {
    "path": "GDLisp.lisp",
    "chars": 49321,
    "preview": "\n;;;; Copyright 2023 Silvio Mayolo\n;;;;\n;;;; This file is part of GDLisp.\n;;;;\n;;;; GDLisp is free software: you can red"
  },
  {
    "path": "MacroServer/TestLoadedFile.gd",
    "chars": 845,
    "preview": "# Copyright 2023 Silvio Mayolo\n#\n# This file is part of GDLisp.\n#\n# GDLisp is free software: you can redistribute it and"
  },
  {
    "path": "MacroServer/main.gd",
    "chars": 5322,
    "preview": "# Copyright 2023 Silvio Mayolo\n#\n# This file is part of GDLisp.\n#\n# GDLisp is free software: you can redistribute it and"
  },
  {
    "path": "MacroServer/main.tscn",
    "chars": 147,
    "preview": "[gd_scene load_steps=2 format=2]\n\n[ext_resource path=\"res://main.gd\" type=\"Script\" id=1]\n\n[node name=\"main\" type=\"Node\"]"
  },
  {
    "path": "MacroServer/project.godot",
    "chars": 106,
    "preview": "\nconfig_version=4\n\n[application]\n\nrun/main_scene=\"res://main.tscn\"\n\n[autoload]\n\nGDLisp=\"*res://GDLisp.gd\"\n"
  },
  {
    "path": "README.md",
    "chars": 2830,
    "preview": "[![GitHub Actions: Ubuntu](https://github.com/mercerenies/gdlisp/actions/workflows/test-Godotv3.5-Ubuntu.yml/badge.svg)]"
  },
  {
    "path": "Rakefile",
    "chars": 1398,
    "preview": "\nrequire 'logger'\nrequire 'fileutils'\n\nif Gem.win_platform?\n  # Needed to be able to create symlinks on Windows.\n  requi"
  },
  {
    "path": "build.rs",
    "chars": 773,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "doc/README.md",
    "chars": 251,
    "preview": "\n# GDLisp Official Documentation\n\nThis is the official documentation for the GDLisp language.\n\n * [`internal/`](internal"
  },
  {
    "path": "doc/internal/CompilationStages.md",
    "chars": 3615,
    "preview": "\n# Compilation Stages\n\n```mermaid\nflowchart LR\n    subgraph AST\n      direction TB\n      Parse[Parse .lisp file into AST"
  },
  {
    "path": "doc/internal/README.md",
    "chars": 80,
    "preview": "\n# Internal GDLisp Documentation\n\n * [Compilation Stages](CompilationStages.md)\n"
  },
  {
    "path": "doc/readthedocs/Makefile",
    "chars": 634,
    "preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the "
  },
  {
    "path": "doc/readthedocs/conf.py",
    "chars": 1029,
    "preview": "# Configuration file for the Sphinx documentation builder.\n#\n# For the full list of built-in configuration values, see t"
  },
  {
    "path": "doc/readthedocs/index.rst",
    "chars": 386,
    "preview": ".. GDLisp documentation master file, created by\n   sphinx-quickstart on Thu Dec  1 12:29:12 2022.\n   You can adapt this "
  },
  {
    "path": "doc/readthedocs/make.bat",
    "chars": 800,
    "preview": "@ECHO OFF\r\n\r\npushd %~dp0\r\n\r\nREM Command file for Sphinx documentation\r\n\r\nif \"%SPHINXBUILD%\" == \"\" (\r\n\tset SPHINXBUILD=sp"
  },
  {
    "path": "doc/readthedocs/reference/classes.rst",
    "chars": 14141,
    "preview": "\n.. _classes:\n\nClasses and Objected-Oriented Programming\n=========================================\n\nGDLisp, like GDScrip"
  },
  {
    "path": "doc/readthedocs/reference/command-line.rst",
    "chars": 4504,
    "preview": "\nThe GDLisp Command Line Tool\n============================\n\nThe core interface to the GDLisp compiler and programming la"
  },
  {
    "path": "doc/readthedocs/reference/datatypes.rst",
    "chars": 5576,
    "preview": "\nBasic Datatypes\n===============\n\nGDLisp compiles to GDScript and runs on the Godot engine, so the core\ndatatypes for GD"
  },
  {
    "path": "doc/readthedocs/reference/expressions.rst",
    "chars": 33424,
    "preview": "\nExpressions\n===========\n\nExpressions are the forms that make up the body of functions and the\ninitial value of variable"
  },
  {
    "path": "doc/readthedocs/reference/imports.rst",
    "chars": 4838,
    "preview": "\n.. _imports:\n\nImport Directives\n=================\n\nGDLisp uses the special ``use`` directive to import names and\nresour"
  },
  {
    "path": "doc/readthedocs/reference/index.rst",
    "chars": 321,
    "preview": "\n.. _comprehensive:\n\nReference Documentation\n=======================\n\n.. toctree::\n   :maxdepth: 2\n   :caption: Contents"
  },
  {
    "path": "doc/readthedocs/reference/lambda-lists.rst",
    "chars": 5278,
    "preview": "\nLambda Lists\n============\n\nFunctions, macros, and constructors in GDLisp take arguments. As part\nof their declaration s"
  },
  {
    "path": "doc/readthedocs/reference/macros.rst",
    "chars": 5396,
    "preview": "\n.. _macros:\n\nMacros\n======\n\nMacros are the key feature that separates a Lisp dialect from many\nconventional programming"
  },
  {
    "path": "doc/readthedocs/reference/parser.rst",
    "chars": 14177,
    "preview": "\n.. _parser:\n\nThe GDLisp Parser\n=================\n\nThe GDLisp language is a Lisp dialect, with a few extensions to make\n"
  },
  {
    "path": "doc/readthedocs/reference/quoting.rst",
    "chars": 4376,
    "preview": "\n.. _quoting:\n\nQuoting and Quasiquoting\n========================\n\nQuoting an S-expression delays its evaluation. That is"
  },
  {
    "path": "doc/readthedocs/reference/source-file.rst",
    "chars": 12341,
    "preview": "\nStructure of a GDLisp Source File\n=================================\n\nA GDLisp source file is, by convention, written wi"
  },
  {
    "path": "doc/readthedocs/reference/standard-library/functions.rst",
    "chars": 20288,
    "preview": "\nBuilt-in Functions\n==================\n\nAll of the GDLisp global functions are documented here. These\nfunctions are avai"
  },
  {
    "path": "doc/readthedocs/reference/standard-library/index.rst",
    "chars": 475,
    "preview": "\nThe GDLisp Standard Library\n===========================\n\nThe GDLisp standard library is provided at runtime by the\n``GD"
  },
  {
    "path": "doc/readthedocs/reference/standard-library/macros.rst",
    "chars": 9430,
    "preview": "\nBuilt-in Macros\n===============\n\nAll of the global macros available in GDLisp are documented here.\n\n``->``\n------\n\n::\n\n"
  },
  {
    "path": "doc/readthedocs/reference/standard-library/types.rst",
    "chars": 6755,
    "preview": "\nTypes and Classes\n=================\n\nThese are all of the class and enumeration constants defined at the\ntop-level in G"
  },
  {
    "path": "doc/readthedocs/reference/standard-library/values.rst",
    "chars": 2390,
    "preview": "\nGlobal Values\n=============\n\nConstant values defined in the GDLisp value namespace at global scope\nare documented here."
  },
  {
    "path": "doc/readthedocs/requirements.txt",
    "chars": 67,
    "preview": "sphinx==5.2.2\nsphinx_rtd_theme==1.1.1\nsphinxcontrib-mermaid==0.7.1\n"
  },
  {
    "path": "doc/readthedocs/tutorial/classes.rst",
    "chars": 12913,
    "preview": "\nClasses in GDLisp\n=================\n\nGDLisp prides itself on being a functional language, capable of\nmanipulating funct"
  },
  {
    "path": "doc/readthedocs/tutorial/control-flow.rst",
    "chars": 18774,
    "preview": "\nBasic Control Flow\n==================\n\nLet's jump right in and take a look at some GDLisp code. Once you've\n:ref:`built"
  },
  {
    "path": "doc/readthedocs/tutorial/index.rst",
    "chars": 844,
    "preview": "\nGetting Started\n===============\n\nWelcome to GDLisp, the Lisp dialect designed to compile to GDScript!\nIf you're interes"
  },
  {
    "path": "doc/readthedocs/tutorial/lisping.rst",
    "chars": 12332,
    "preview": "\nIntroduction to Lisp\n====================\n\nThe term \"Lisp\" encompasses a broad collection of programming\nlanguages dati"
  },
  {
    "path": "doc/readthedocs/tutorial/macros.rst",
    "chars": 5245,
    "preview": "\nMacros\n======\n\nMacros are the centerpiece of any Lisp. Macros provide a mechanism for\nmodifying the code of your progra"
  },
  {
    "path": "doc/readthedocs/tutorial/modules.rst",
    "chars": 9094,
    "preview": "\nFunctions and Modules\n=====================\n\nNow that we have some basic tools to do calculations and store\nvariables i"
  },
  {
    "path": "doc/readthedocs/tutorial/what-now.rst",
    "chars": 409,
    "preview": "\nWhat's Next\n===========\n\nThis has been a whirlwind tour of the basic features of GDLisp. More\ncomprehensive documentati"
  },
  {
    "path": "minimal.txt",
    "chars": 1426,
    "preview": "\nCommand to build Godot with minimal modules, for testing:\n\n> scons platform=server tools=yes target=release_debug disab"
  },
  {
    "path": "src/command_line.rs",
    "chars": 3632,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/args.rs",
    "chars": 12167,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/body/builder.rs",
    "chars": 4786,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/body/class_initializer.rs",
    "chars": 13269,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/body/class_scope.rs",
    "chars": 5860,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/body/mod.rs",
    "chars": 855,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/body/super_proxy.rs",
    "chars": 2818,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/body/synthetic_field.rs",
    "chars": 3576,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/constant.rs",
    "chars": 10091,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/error.rs",
    "chars": 29672,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/factory.rs",
    "chars": 14303,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/frame.rs",
    "chars": 31057,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/import.rs",
    "chars": 1893,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/mod.rs",
    "chars": 28543,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/names/contextual.rs",
    "chars": 3101,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/names/fresh.rs",
    "chars": 5122,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/names/generator.rs",
    "chars": 1359,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/names/mod.rs",
    "chars": 8882,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/names/registered.rs",
    "chars": 3247,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/names/reserved.rs",
    "chars": 4481,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/preload_resolver.rs",
    "chars": 4447,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/resource_type.rs",
    "chars": 4764,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/closure.rs",
    "chars": 10071,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/flet.rs",
    "chars": 9117,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/lambda.rs",
    "chars": 20910,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/lambda_class.rs",
    "chars": 8531,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/lambda_vararg/builder.rs",
    "chars": 7422,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/lambda_vararg/mod.rs",
    "chars": 6419,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/let_block.rs",
    "chars": 2541,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/special_form/mod.rs",
    "chars": 6955,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/stateful.rs",
    "chars": 7982,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/stmt_wrapper.rs",
    "chars": 4647,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/symbol_table/call_magic/mod.rs",
    "chars": 23642,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/symbol_table/call_magic/table.rs",
    "chars": 2619,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/symbol_table/function_call.rs",
    "chars": 22353,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/symbol_table/inner.rs",
    "chars": 2731,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/symbol_table/local_var.rs",
    "chars": 25107,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/compile/symbol_table/mod.rs",
    "chars": 19129,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/arglist.rs",
    "chars": 5933,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/class_extends.rs",
    "chars": 2745,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/decl.rs",
    "chars": 22101,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/expr.rs",
    "chars": 19443,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/expr_wrapper.rs",
    "chars": 2115,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/inner_class.rs",
    "chars": 6531,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/cell.rs",
    "chars": 3545,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/class_loader.rs",
    "chars": 7913,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/constant_loader.rs",
    "chars": 6117,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/api_type.rs",
    "chars": 1764,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/argument.rs",
    "chars": 1873,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/class.rs",
    "chars": 3393,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/gdnative_enum.rs",
    "chars": 1525,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/method.rs",
    "chars": 2249,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/mod.rs",
    "chars": 3661,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/property.rs",
    "chars": 1547,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/gdnative/signal.rs",
    "chars": 1597,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/magic.rs",
    "chars": 7978,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/library/mod.rs",
    "chars": 8611,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/literal.rs",
    "chars": 5405,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/metadata.rs",
    "chars": 6112,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/mod.rs",
    "chars": 4458,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/op.rs",
    "chars": 5762,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/pattern.rs",
    "chars": 4380,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/spacing.rs",
    "chars": 3214,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/gdscript/stmt.rs",
    "chars": 16683,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/graph/mod.rs",
    "chars": 6057,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/graph/tarjan.rs",
    "chars": 8367,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/graph/top_sort.rs",
    "chars": 3161,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/access_type.rs",
    "chars": 7928,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/constructor.rs",
    "chars": 5174,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/error.rs",
    "chars": 3576,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/general.rs",
    "chars": 3931,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/mod.rs",
    "chars": 4555,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/ordinary.rs",
    "chars": 7358,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/parser.rs",
    "chars": 6254,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/simple.rs",
    "chars": 3933,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/arglist/vararg.rs",
    "chars": 1807,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/bootstrapping.rs",
    "chars": 4537,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/call_name.rs",
    "chars": 6907,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/classification.rs",
    "chars": 4830,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/closure_names.rs",
    "chars": 5408,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/decl.rs",
    "chars": 26727,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/declaration_table.rs",
    "chars": 4899,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/depends.rs",
    "chars": 3506,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/export.rs",
    "chars": 2372,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/expr.rs",
    "chars": 25712,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/identifier.rs",
    "chars": 6414,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/import.rs",
    "chars": 15537,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/incremental.rs",
    "chars": 38098,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/literal.rs",
    "chars": 1491,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/loops/error.rs",
    "chars": 3291,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/loops/mod.rs",
    "chars": 6888,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/macros.rs",
    "chars": 3622,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/main_function.rs",
    "chars": 3526,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/mod.rs",
    "chars": 8161,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/class.rs",
    "chars": 1753,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/constant.rs",
    "chars": 1438,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/declare.rs",
    "chars": 1435,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/enums.rs",
    "chars": 1406,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/file.rs",
    "chars": 2549,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/function.rs",
    "chars": 1776,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/instance_method.rs",
    "chars": 2399,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/macros.rs",
    "chars": 1574,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/magic.rs",
    "chars": 2202,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/mod.rs",
    "chars": 9667,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/var.rs",
    "chars": 1422,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/modifier/visibility.rs",
    "chars": 1404,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/quasiquote.rs",
    "chars": 10378,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/scope/decl.rs",
    "chars": 7222,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/scope/error.rs",
    "chars": 1631,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/scope/mod.rs",
    "chars": 3697,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/scope/name_table/builder.rs",
    "chars": 2589,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/scope/name_table/mod.rs",
    "chars": 7208,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/special_form/access_slot.rs",
    "chars": 2082,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/special_form/assignment.rs",
    "chars": 1425,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/special_form/local_binding.rs",
    "chars": 1937,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/special_form/mod.rs",
    "chars": 29205,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/ir/special_ref.rs",
    "chars": 2414,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/lib.rs",
    "chars": 1295,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/main.rs",
    "chars": 6207,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/assignment.rs",
    "chars": 2299,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/basic_math_ops.rs",
    "chars": 1869,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/constant.rs",
    "chars": 5236,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/constant_conditional_branch.rs",
    "chars": 3343,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/dead_code_elimination.rs",
    "chars": 3275,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/dead_decl_elimination.rs",
    "chars": 2479,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/dead_var_elimination.rs",
    "chars": 1811,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/direct_var_substitute.rs",
    "chars": 2274,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/else_then_if_fold.rs",
    "chars": 3179,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/expr_walker.rs",
    "chars": 5140,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/mod.rs",
    "chars": 7181,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/noop.rs",
    "chars": 2827,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/redundant_assignment_elimination.rs",
    "chars": 11014,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/stmt_walker.rs",
    "chars": 7842,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/ternary_if_fold.rs",
    "chars": 7365,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/gdscript/variables.rs",
    "chars": 2250,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/ir/expr_walker.rs",
    "chars": 11595,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/ir/mod.rs",
    "chars": 888,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/optimize/mod.rs",
    "chars": 728,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/parser.lalrpop",
    "chars": 6055,
    "preview": "// -*- Rust -*-\n\n// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you c"
  },
  {
    "path": "src/parser_test.rs",
    "chars": 7646,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/can_load.rs",
    "chars": 2353,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/config.rs",
    "chars": 1576,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/error.rs",
    "chars": 5621,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/loader.rs",
    "chars": 1614,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/mod.rs",
    "chars": 10335,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/resolver.rs",
    "chars": 3719,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/source.rs",
    "chars": 9305,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/stdlib_unit.rs",
    "chars": 1590,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  },
  {
    "path": "src/pipeline/translation_unit.rs",
    "chars": 4452,
    "preview": "// Copyright 2023 Silvio Mayolo\n//\n// This file is part of GDLisp.\n//\n// GDLisp is free software: you can redistribute i"
  }
]

// ... and 67 more files (download for full content)