Refactored AST workspaces to use arenas

Author: IsaacShelton

Cargo.lock

@@ -41,7 +41,7 @@ members = [
     "src/components/build_c_token",
     "src/support/look_ahead",
     "src/support/repeating_last",
-    "src/support/backend",
+    "src/support/backend", "src/components/job", "src/support/arena",
 ]
 
 [workspace.dependencies]
@@ -57,13 +57,9 @@ memo-map = "0.3.2"
 indexmap = "2.2.5"
 itertools = "0.13.0"
 lazy_format = "2.0.3"
-bit-vec = "0.8.0"
-thin-vec = "0.2.13"
-walkdir = "2.5.0"
 once_map = "0.4.18"
 num = "0.4.3"
 num-derive = "0.4.2"
-bitvec = "1.0.1"
 derivative = "2.2.0"
 ignore = "0.4.22"
 humansize = "2.1.3"

Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+arena = { version = "0.1.0", path = "../../support/arena" }
 asg = { version = "0.1.0", path = "../../representations/asg" }
 ast = { version = "0.1.0", path = "../../representations/ast" }
 ast_workspace = { version = "0.1.0", path = "../../representations/ast_workspace" }

src/components/build_asg/Cargo.toml

@@ -2,14 +2,14 @@ use super::{ctx::ResolveCtx, error::ResolveError};
 use asg::HelperExprDecl;
 use ast_workspace::AstWorkspace;
 
-pub fn resolve_helper_expressions(
+pub fn resolve_expr_aliases(
     ctx: &mut ResolveCtx,
     ast_workspace: &AstWorkspace,
 ) -> Result<(), ResolveError> {
     for (physical_file_id, file) in ast_workspace.files.iter() {
-        let module_folder_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
+        let module_folder_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
-        for helper_expr in file.helper_exprs.iter() {
+        for helper_expr in ast_workspace.view(file).expr_aliases {
             let helper_exprs = ctx
                 .helper_exprs_in_modules
                 .entry(module_folder_id)

src/components/build_asg/src/helper_expr.rs src/components/build_asg/src/expr_alias.rs

@@ -21,15 +21,7 @@ pub fn resolve_func_bodies(
             FuncJob::Regular(physical_file_id, ast_func_index, func_ref) => {
                 let module_folder_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
-                let ast_file = ast_workspace
-                    .files
-                    .get(&physical_file_id)
-                    .expect("file referenced by job to exist");
-
-                let ast_function = ast_file
-                    .funcs
-                    .get(ast_func_index)
-                    .expect("function referenced by job to exist");
+                let ast_function = &ast_workspace.all_funcs[ast_func_index];
 
                 resolve_func_body(
                     ctx,
@@ -49,15 +41,7 @@ pub fn resolve_func_bodies(
             ) => {
                 let module_folder_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
-                let ast_file = ast_workspace
-                    .files
-                    .get(&physical_file_id)
-                    .expect("file referenced by job to exist");
-
-                let ast_function = ast_file
-                    .impls
-                    .get(ast_impl_index)
-                    .expect("referenced impl to exist")
+                let ast_function = ast_workspace.all_impls[ast_impl_index]
                     .body
                     .get(ast_impl_function_index)
                     .expect("referenced impl function to exist");
@@ -103,10 +87,10 @@ fn resolve_func_body(
 
     let file = ast_workspace
         .files
-        .get(&physical_file_id)
+        .get(physical_file_id)
         .expect("referenced file exists");
 
-    let settings = &ast_workspace.settings[file.settings.unwrap_or_default().0];
+    let settings = &ast_workspace.settings[file.settings.unwrap_or(ast_workspace.default_settings)];
 
     let resolved_stmts = resolve_stmts(
         &mut ResolveExprCtx {

src/components/build_asg/src/func_body.rs

@@ -22,14 +22,23 @@ pub fn create_func_heads<'a>(
     ast_workspace: &AstWorkspace,
     options: &BuildOptions,
 ) -> Result<(), ResolveError> {
-    for (physical_file_id, file) in ast_workspace.files.iter() {
-        let module_folder_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
+    for (physical_file_id, ast_file) in ast_workspace.files.iter() {
+        let module_folder_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
-        create_impl_heads(ctx, asg, options, module_folder_id, *physical_file_id, file)?;
+        create_impl_heads(
+            ctx,
+            asg,
+            options,
+            module_folder_id,
+            physical_file_id,
+            ast_file,
+        )?;
+
+        for func_id in ast_file.funcs.iter() {
+            let func = &ast_workspace.all_funcs[func_id];
 
-        for (func_i, func) in file.funcs.iter().enumerate() {
             let name = if func.head.privacy.is_private() {
-                ResolvedName::new(*physical_file_id, &Name::plain(&func.head.name))
+                ResolvedName::new(physical_file_id, &Name::plain(&func.head.name))
             } else {
                 ResolvedName::new(module_folder_id, &Name::plain(&func.head.name))
             };
@@ -41,7 +50,7 @@ pub fn create_func_heads<'a>(
                 name.clone(),
                 &func.head,
                 module_folder_id,
-                *physical_file_id,
+                physical_file_id,
             )?;
 
             if func.head.privacy.is_public() {
@@ -53,8 +62,10 @@ pub fn create_func_heads<'a>(
                     .push(func_ref);
             }
 
-            let settings = file.settings.map(|id| &ast_workspace.settings[id.0]);
-            let imported_namespaces = settings.map(|settings| &settings.imported_namespaces);
+            let imported_namespaces = ast_workspace
+                .view(ast_file)
+                .settings
+                .map(|settings| &settings.imported_namespaces);
 
             let func_haystack = ctx.func_haystacks.get_or_insert_with(module_folder_id, || {
                 FuncHaystack::new(
@@ -72,7 +83,7 @@ pub fn create_func_heads<'a>(
                 .or_insert_with(|| vec![func_ref]);
 
             ctx.jobs
-                .push_back(FuncJob::Regular(*physical_file_id, func_i, func_ref));
+                .push_back(FuncJob::Regular(physical_file_id, func_id, func_ref));
         }
     }
 

src/components/build_asg/src/func_head.rs

@@ -13,13 +13,13 @@ pub fn resolve_global_variables(
     ast_workspace: &AstWorkspace,
 ) -> Result<(), ResolveError> {
     for (physical_file_id, file) in ast_workspace.files.iter() {
-        let module_folder_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
+        let module_folder_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
-        for global in file.global_variables.iter() {
+        for global in ast_workspace.view(file).globals.iter() {
             let type_ctx = ResolveTypeCtx::new(
                 &asg,
                 module_folder_id,
-                *physical_file_id,
+                physical_file_id,
                 &ctx.types_in_modules,
             );
 
@@ -35,7 +35,7 @@ pub fn resolve_global_variables(
             });
 
             let fs_node_id = if global.privacy.is_private() {
-                *physical_file_id
+                physical_file_id
             } else {
                 module_folder_id
             };

src/components/build_asg/src/global_variable.rs

@@ -5,7 +5,8 @@ use super::{
 };
 use crate::{error::ResolveErrorKind, type_ctx::ResolveTypeCtx};
 use asg::{Asg, Func, GenericTraitRef, ImplDecl, ImplRef, ResolvedName, TraitFunc, Type};
-use ast::{AstFile, Name};
+use ast::Name;
+use ast_workspace::AstFile;
 use attributes::Privacy;
 use compiler::BuildOptions;
 use for_alls::ForAlls;
@@ -20,9 +21,10 @@ pub fn create_impl_heads(
     options: &BuildOptions,
     module_folder_id: FsNodeId,
     physical_file_id: FsNodeId,
-    file: &AstFile,
+    ast_file: &AstFile,
 ) -> Result<(), ResolveError> {
-    for (impl_i, ast_impl) in file.impls.iter().enumerate() {
+    for impl_id in ast_file.impls.iter() {
+        let ast_impl = &asg.workspace.all_impls[impl_id];
         let impl_ref = create_impl_head(ctx, asg, module_folder_id, physical_file_id, ast_impl)?;
 
         for (func_i, func) in ast_impl.body.iter().enumerate() {
@@ -61,8 +63,12 @@ pub fn create_impl_heads(
 
             ensure_satisfies_trait_func(ctx, asg, expected, trait_func, impl_func)?;
 
-            ctx.jobs
-                .push_back(FuncJob::Impling(physical_file_id, impl_i, func_i, func_ref));
+            ctx.jobs.push_back(FuncJob::Impling(
+                physical_file_id,
+                impl_id,
+                func_i,
+                func_ref,
+            ));
 
             if asg
                 .impls

src/components/build_asg/src/impl_head/mod.rs

@@ -1,10 +1,12 @@
+use arena::Idx;
 use asg::{EnumRef, StructRef, TraitRef, TypeAliasRef};
+use ast_workspace::{FuncId, ImplId};
 use fs_tree::FsNodeId;
 
 #[derive(Clone, Debug)]
 pub enum FuncJob {
-    Regular(FsNodeId, usize, asg::FuncRef),
-    Impling(FsNodeId, usize, usize, asg::FuncRef),
+    Regular(FsNodeId, Idx<FuncId, ast::Func>, asg::FuncRef),
+    Impling(FsNodeId, Idx<ImplId, ast::Impl>, usize, asg::FuncRef),
 }
 
 #[derive(Clone, Debug)]

src/components/build_asg/src/job.rs

@@ -5,11 +5,11 @@ mod ctx;
 mod destination;
 mod error;
 mod expr;
+mod expr_alias;
 mod func_body;
 mod func_haystack;
 mod func_head;
 mod global_variable;
-mod helper_expr;
 mod impl_head;
 mod initialized;
 mod job;
@@ -26,10 +26,10 @@ use ast_workspace::AstWorkspace;
 use compiler::BuildOptions;
 use ctx::ResolveCtx;
 use error::ResolveError;
+use expr_alias::resolve_expr_aliases;
 use func_body::resolve_func_bodies;
 use func_head::create_func_heads;
 use global_variable::resolve_global_variables;
-use helper_expr::resolve_helper_expressions;
 use initialized::Initialized;
 pub use polymorph::*;
 pub use stmt::resolve_stmts;
@@ -48,7 +48,7 @@ pub fn resolve<'a>(
     resolve_type_definitions(&mut ctx, &mut asg, workspace)?;
     resolve_global_variables(&mut ctx, &mut asg, workspace)?;
     create_func_heads(&mut ctx, &mut asg, workspace, options)?;
-    resolve_helper_expressions(&mut ctx, workspace)?;
+    resolve_expr_aliases(&mut ctx, workspace)?;
     resolve_func_bodies(&mut ctx, &mut asg, workspace)?;
 
     Ok(asg)

src/components/build_asg/src/lib.rs

@@ -16,11 +16,10 @@ impl<'a> ResolveTypeCtx<'a> {
             .asg
             .workspace
             .files
-            .get(&self.file_fs_node_id)
+            .get(self.file_fs_node_id)
             .unwrap()
             .settings
-            .expect("valid settings id")
-            .0];
+            .expect("valid settings id")];
 
         let decl = name
             .as_plain_str()

src/components/build_asg/src/type_ctx/find.rs

@@ -17,10 +17,11 @@ pub fn prepare_type_jobs(
     asg: &mut Asg,
     ast_workspace: &AstWorkspace,
 ) -> Result<Vec<TypeJob>, ResolveError> {
-    let mut type_jobs = Vec::with_capacity(ast_workspace.files.len());
+    let mut type_jobs = Vec::new();
 
     for (physical_file_id, file) in ast_workspace.files.iter() {
-        let physical_file_id = *physical_file_id;
+        let file = ast_workspace.view(file);
+        let physical_file_id = physical_file_id;
         let module_fs_node_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
         let mut job = TypeJob {

src/components/build_asg/src/type_definition/prepare.rs

@@ -19,10 +19,12 @@ pub fn resolve_type_jobs(
     type_jobs: &[TypeJob],
 ) -> Result<(), ResolveError> {
     for job in type_jobs.iter() {
-        let file = ast_workspace
-            .files
-            .get(&job.physical_file_id)
-            .expect("valid ast file");
+        let file = ast_workspace.view(
+            ast_workspace
+                .files
+                .get(job.physical_file_id)
+                .expect("valid ast file"),
+        );
 
         let module_folder_id = ast_workspace.get_owning_module_or_self(job.physical_file_id);