Removed old impl gathering infrastructure

src/pragma_section/run.rs

@@ -7,7 +7,6 @@ use crate::{
     lower::lower,
     parser::error::ParseErrorKind,
     resolve::resolve,
-    resolved::Implementations,
     show::{into_show, Show},
     target::Target,
     workspace::fs::Fs,
@@ -48,10 +47,7 @@ impl PragmaSection {
         let files = IndexMap::from_iter(std::iter::once((fs_node_id, self.ast_file)));
         let workspace = AstWorkspace::new(fs, files, base_compiler.source_files, None);
 
-        let implementations = Implementations::new();
-        let resolved_ast =
-            resolve(&workspace, &implementations, &compiler.options).map_err(into_show)?;
-
+        let resolved_ast = resolve(&workspace, &compiler.options).map_err(into_show)?;
         let ir_module = lower(&compiler.options, &resolved_ast).map_err(into_show)?;
 
         let mut user_settings = run_build_system_interpreter(&resolved_ast, &ir_module)

src/resolve/ctx.rs

@@ -1,31 +1,30 @@
 use super::{function_haystack::FunctionHaystack, job::FuncJob};
-use crate::{
-    resolved::{self, Implementations},
-    workspace::fs::FsNodeId,
-};
+use crate::{resolved, workspace::fs::FsNodeId};
 use indexmap::IndexMap;
 use std::collections::{HashMap, VecDeque};
 
-pub struct ResolveCtx<'a> {
+pub struct ResolveCtx {
     pub jobs: VecDeque<FuncJob>,
     pub function_haystacks: IndexMap<FsNodeId, FunctionHaystack>,
     pub public_functions: HashMap<FsNodeId, HashMap<String, Vec<resolved::FunctionRef>>>,
     pub types_in_modules: HashMap<FsNodeId, HashMap<String, resolved::TypeDecl>>,
     pub globals_in_modules: HashMap<FsNodeId, HashMap<String, resolved::GlobalVarDecl>>,
     pub helper_exprs_in_modules: HashMap<FsNodeId, HashMap<String, resolved::HelperExprDecl>>,
-    pub implementations: &'a Implementations,
+    pub trait_haystacks: HashMap<FsNodeId, HashMap<String, resolved::TraitRef>>,
+    pub impl_haystacks: HashMap<FsNodeId, HashMap<String, resolved::TraitRef>>,
 }
 
-impl<'a> ResolveCtx<'a> {
-    pub fn new(implementations: &'a Implementations) -> Self {
+impl ResolveCtx {
+    pub fn new() -> Self {
         Self {
             jobs: Default::default(),
             function_haystacks: Default::default(),
             public_functions: HashMap::new(),
             types_in_modules: HashMap::new(),
             globals_in_modules: HashMap::new(),
             helper_exprs_in_modules: HashMap::new(),
-            implementations,
+            trait_haystacks: HashMap::new(),
+            impl_haystacks: HashMap::new(),
         }
     }
 }

src/resolve/expr/mod.rs

@@ -59,7 +59,7 @@ pub struct ResolveExprCtx<'a, 'b> {
     pub helper_exprs_in_modules: &'b HashMap<FsNodeId, HashMap<String, resolved::HelperExprDecl>>,
     pub module_fs_node_id: FsNodeId,
     pub physical_fs_node_id: FsNodeId,
-    pub current_constraints: CurrentConstraints<'b>,
+    pub current_constraints: CurrentConstraints,
 }
 
 impl<'a, 'b> ResolveExprCtx<'a, 'b> {

src/resolve/function_head.rs

@@ -15,13 +15,13 @@ use crate::{
 use std::collections::{HashMap, HashSet};
 
 fn create_impl_head<'a>(
-    ctx: &mut ResolveCtx<'a>,
+    ctx: &mut ResolveCtx,
     resolved_ast: &mut resolved::Ast<'a>,
     module_file_id: FsNodeId,
     physical_file_id: FsNodeId,
     imp: &ast::Impl,
 ) -> Result<resolved::ImplRef, ResolveError> {
-    let pre_parameters_constraints = CurrentConstraints::new_empty(ctx.implementations);
+    let pre_parameters_constraints = CurrentConstraints::new_empty();
 
     let type_ctx = ResolveTypeCtx::new(
         &resolved_ast,
@@ -42,7 +42,7 @@ fn create_impl_head<'a>(
 }
 
 pub fn create_function_heads<'a>(
-    ctx: &mut ResolveCtx<'a>,
+    ctx: &mut ResolveCtx,
     resolved_ast: &mut resolved::Ast<'a>,
     ast_workspace: &AstWorkspace,
     options: &BuildOptions,
@@ -130,15 +130,15 @@ pub fn create_function_heads<'a>(
 }
 
 pub fn create_function_head<'a>(
-    ctx: &mut ResolveCtx<'a>,
+    ctx: &mut ResolveCtx,
     resolved_ast: &mut resolved::Ast<'a>,
     options: &BuildOptions,
     name: ResolvedName,
     head: &FunctionHead,
     module_file_id: FsNodeId,
     physical_file_id: FsNodeId,
 ) -> Result<FunctionRef, ResolveError> {
-    let pre_parameters_constraints = CurrentConstraints::new_empty(ctx.implementations);
+    let pre_parameters_constraints = CurrentConstraints::new_empty();
 
     let type_ctx = ResolveTypeCtx::new(
         &resolved_ast,
@@ -169,10 +169,7 @@ pub fn create_function_head<'a>(
             (options.coerce_main_signature && head.name == "main").then_some(Tag::Main)
         }),
         is_generic,
-        constraints: CurrentConstraints {
-            constraints,
-            implementations: ctx.implementations,
-        },
+        constraints: CurrentConstraints::new(constraints),
     }))
 }
 

src/resolve/global_variable.rs

@@ -10,7 +10,7 @@ pub fn resolve_global_variables(
     resolved_ast: &mut resolved::Ast,
     ast_workspace: &AstWorkspace,
 ) -> Result<(), ResolveError> {
-    let constraints = CurrentConstraints::new_empty(ctx.implementations);
+    let constraints = CurrentConstraints::new_empty();
 
     for (physical_file_id, file) in ast_workspace.files.iter() {
         let module_file_id = ast_workspace.get_owning_module_or_self(*physical_file_id);

src/resolve/helper_expr.rs

@@ -40,7 +40,7 @@ pub fn resolve_helper_expressions(
                     helper_exprs_in_modules: &ctx.helper_exprs_in_modules,
                     module_fs_node_id: module_file_id,
                     physical_fs_node_id: *physical_file_id,
-                    current_constraints: CurrentConstraints::new_empty(ctx.implementations),
+                    current_constraints: CurrentConstraints::new_empty(),
                 };
 
                 resolve_expr(&mut ctx, &helper_expr.value, None, Initialized::Require)?

src/resolve/mod.rs

@@ -19,11 +19,7 @@ mod unify_types;
 mod variable_haystack;
 
 use self::error::ResolveError;
-use crate::{
-    ast::AstWorkspace,
-    cli::BuildOptions,
-    resolved::{self, Implementations},
-};
+use crate::{ast::AstWorkspace, cli::BuildOptions, resolved};
 use ctx::ResolveCtx;
 use function_body::resolve_function_bodies;
 use function_head::create_function_heads;
@@ -37,10 +33,9 @@ use type_definition::resolve_type_definitions;
 
 pub fn resolve<'a>(
     ast_workspace: &'a AstWorkspace,
-    implementations: &'a Implementations,
     options: &BuildOptions,
 ) -> Result<resolved::Ast<'a>, ResolveError> {
-    let mut ctx = ResolveCtx::new(implementations);
+    let mut ctx = ResolveCtx::new();
     let source_files = ast_workspace.source_files;
     let mut resolved_ast = resolved::Ast::new(source_files, &ast_workspace);
 

src/resolve/type_ctx/mod.rs

@@ -21,7 +21,7 @@ pub struct ResolveTypeCtx<'a> {
     file_fs_node_id: FsNodeId,
     types_in_modules: &'a HashMap<FsNodeId, HashMap<String, resolved::TypeDecl>>,
     used_aliases_stack: HashSet<ResolvedName>,
-    current_constraints: &'a CurrentConstraints<'a>,
+    current_constraints: &'a CurrentConstraints,
 }
 
 impl<'a> ResolveTypeCtx<'a> {

src/resolve/type_definition/prepare.rs

@@ -88,7 +88,7 @@ fn prepare_structure(
     let mut parameters = TypeParameters::default();
 
     for (name, parameter) in structure.parameters.iter() {
-        let zero_current_constraints = CurrentConstraints::new_empty(ctx.implementations);
+        let zero_current_constraints = CurrentConstraints::new_empty();
         let constraints = resolve_constraints(
             &ResolveTypeCtx::new(
                 resolved_ast,

src/resolve/type_definition/resolve.rs

@@ -88,7 +88,7 @@ fn resolve_structure(
     structure_ref: StructureRef,
 ) -> Result<(), ResolveError> {
     for (field_name, field) in structure.fields.iter() {
-        let pre_constraints = CurrentConstraints::new_empty(ctx.implementations);
+        let pre_constraints = CurrentConstraints::new_empty();
         let pre_type_ctx = ResolveTypeCtx::new(
             &resolved_ast,
             module_file_id,
@@ -107,10 +107,7 @@ fn resolve_structure(
             );
         }
 
-        let constraints = CurrentConstraints {
-            constraints,
-            implementations: ctx.implementations,
-        };
+        let constraints = CurrentConstraints::new(constraints);
 
         let type_ctx = ResolveTypeCtx::new(
             &resolved_ast,
@@ -148,7 +145,7 @@ fn resolve_enum(
     definition: &ast::Enum,
     enum_ref: EnumRef,
 ) -> Result<(), ResolveError> {
-    let constraints = CurrentConstraints::new_empty(ctx.implementations);
+    let constraints = CurrentConstraints::new_empty();
     let type_ctx = ResolveTypeCtx::new(
         &resolved_ast,
         module_file_id,
@@ -176,7 +173,7 @@ fn resolve_type_alias(
     definition: &ast::TypeAlias,
     type_alias_ref: TypeAliasRef,
 ) -> Result<(), ResolveError> {
-    let constraints = CurrentConstraints::new_empty(ctx.implementations);
+    let constraints = CurrentConstraints::new_empty();
     let type_ctx = ResolveTypeCtx::new(
         &resolved_ast,
         module_file_id,
@@ -198,7 +195,7 @@ fn resolve_trait(
     definition: &ast::Trait,
     trait_ref: TraitRef,
 ) -> Result<(), ResolveError> {
-    let constraints = CurrentConstraints::new_empty(ctx.implementations);
+    let constraints = CurrentConstraints::new_empty();
     let type_ctx = ResolveTypeCtx::new(
         &resolved_ast,
         module_file_id,

src/resolved/function.rs

@@ -2,29 +2,18 @@ use crate::{name::ResolvedName, resolved::*, source_files::Source, tag::Tag};
 use std::{collections::HashSet, fmt::Display};
 
 #[derive(Clone, Debug)]
-pub struct CurrentConstraints<'a> {
-    pub constraints: HashMap<String, HashSet<Constraint>>,
-    pub implementations: &'a Implementations,
+pub struct CurrentConstraints {
+    constraints: HashMap<String, HashSet<Constraint>>,
 }
 
-#[derive(Clone, Debug, Default)]
-pub struct Implementations {
-    targeting_trait: HashMap<TraitRef, ()>,
-}
-
-impl Implementations {
-    pub fn new() -> Self {
-        Self {
-            targeting_trait: Default::default(),
-        }
+impl<'a> CurrentConstraints {
+    pub fn new(constraints: HashMap<String, HashSet<Constraint>>) -> Self {
+        Self { constraints }
     }
-}
 
-impl<'a> CurrentConstraints<'a> {
-    pub fn new_empty(implementations: &'a Implementations) -> Self {
+    pub fn new_empty() -> Self {
         Self {
             constraints: Default::default(),
-            implementations,
         }
     }
 
@@ -58,7 +47,7 @@ impl<'a> CurrentConstraints<'a> {
 }
 
 #[derive(Clone, Debug)]
-pub struct Function<'a> {
+pub struct Function {
     pub name: ResolvedName,
     pub parameters: Parameters,
     pub return_type: Type,
@@ -69,7 +58,7 @@ pub struct Function<'a> {
     pub source: Source,
     pub abide_abi: bool,
     pub tag: Option<Tag>,
-    pub constraints: CurrentConstraints<'a>,
+    pub constraints: CurrentConstraints,
 }
 
 #[derive(Clone, Debug, Default)]

src/resolved/mod.rs

@@ -51,7 +51,7 @@ new_key_type! {
 pub struct Ast<'a> {
     pub source_files: &'a SourceFiles,
     pub entry_point: Option<FunctionRef>,
-    pub functions: SlotMap<FunctionRef, Function<'a>>,
+    pub functions: SlotMap<FunctionRef, Function>,
     pub structures: SlotMap<StructureRef, Structure>,
     pub globals: SlotMap<GlobalVarRef, GlobalVar>,
     pub enums: SlotMap<EnumRef, Enum>,

src/workspace/mod.rs

@@ -22,7 +22,6 @@ use crate::{
     interpreter_env::{run_build_system_interpreter, setup_build_system_interpreter_symbols},
     lower::lower,
     resolve::resolve,
-    resolved::Implementations,
     unerror::unerror,
     workspace::export_and_link::export_and_link,
 };
@@ -78,11 +77,7 @@ pub fn compile_workspace(
     let workspace = AstWorkspace::new(fs, files, compiler.source_files, Some(module_folders));
 
     // Resolve symbols and validate semantics for workspace
-    let implementations = Implementations::new();
-    let resolved_ast = unerror(
-        resolve(&workspace, &implementations, &compiler.options),
-        source_files,
-    )?;
+    let resolved_ast = unerror(resolve(&workspace, &compiler.options), source_files)?;
 
     // Lower code to high level intermediate representation
     let ir_module = unerror(lower(&compiler.options, &resolved_ast), source_files)?;