Retrieve basic arch

ohdlc/src/ir/architectures.rs

@@ -0,0 +1,13 @@
+use std::fmt::Debug;
+use surotto::simple_key;
+
+use crate::ast;
+
+use super::name_lookup::ScopeId;
+
+simple_key!(
+    pub struct ArchId;
+);
+
+#[derive(Debug)]
+pub struct RoughArch<'ast>(pub ScopeId, pub &'ast ast::Arch<'ast>);

ohdlc/src/ir/mod.rs

@@ -1,3 +1,4 @@
+pub mod architectures;
 pub mod import_bucket;
 pub mod modules;
 pub mod name_lookup;

ohdlc/src/ir/registry.rs

@@ -1,21 +1,27 @@
 use surotto::{simple::SimpleSurotto, simple_key};
 
-use super::modules::{Module, ModuleId};
+use super::{
+    architectures::ArchId,
+    modules::{Module, ModuleId},
+};
 
 #[derive(Debug)]
-pub struct Registry<T> {
+pub struct Registry<T, A> {
     pub modules: ModuleRegistry,
     pub types: TypeRegistry<T>,
+    pub architectures: ArchRegistry<A>,
 }
 
 pub type ModuleRegistry = SimpleSurotto<ModuleId, Module>;
 pub type TypeRegistry<T> = SimpleSurotto<TypeId, T>;
+pub type ArchRegistry<A> = SimpleSurotto<ArchId, A>;
 
-impl<T> Default for Registry<T> {
+impl<T, A> Default for Registry<T, A> {
     fn default() -> Self {
         Self {
             modules: SimpleSurotto::new(),
             types: SimpleSurotto::new(),
+            architectures: SimpleSurotto::new(),
         }
     }
 }

ohdlc/src/ir/stages/architectures/mod.rs

@@ -0,0 +1,83 @@
+use bumpalo::Bump;
+
+use crate::{
+    ast,
+    ir::{
+        architectures::{ArchId, RoughArch},
+        import_bucket::LookupStrategy,
+        name_lookup::{PostFlattenNameLookup, Resolved, ScopeId},
+        registry::{Registry, TypeId},
+    },
+    message::Message,
+    MESSAGES,
+};
+
+use super::refine_types::types::RefinedType;
+
+pub struct ArchitectureStage<'ir, 'b, 'ast> {
+    pub arena: &'ir Bump,
+    pub name_lookup: &'b PostFlattenNameLookup,
+    pub registry: &'ast Registry<RefinedType<'ir>, RoughArch<'ast>>,
+}
+
+impl<'ir, 'ast> ArchitectureStage<'ir, '_, 'ast> {
+    pub fn lower(self) {
+        for (id, arch) in self.registry.architectures.iter() {
+            self.lower_arch(id, arch)
+        }
+    }
+
+    fn lower_arch(&self, id: ArchId, arch: &RoughArch<'ast>) {
+        let ty = self.lookup_type(arch.0, &arch.1.ty);
+        println!("Implementing arch '{}' for {:?}", arch.1.name.0.get(), ty);
+    }
+
+    // TODO: equal to one in `architectures`, fix duplicate pls
+    fn lookup_type(&self, scope: ScopeId, ty: &ast::Type) -> Option<TypeId> {
+        let mut lookup_scope = match ty.path.0 .1 {
+            ast::PathStart::Root => self.name_lookup.root,
+            ast::PathStart::Local => scope,
+        };
+
+        let mut path = ty.path.0 .0.iter().peekable();
+        let mut is_start = true;
+        while let Some(segment) = path.next() {
+            let is_terminal = path.peek().is_none();
+            let segment = segment.0;
+
+            let lookup = self.name_lookup.lookup(
+                lookup_scope,
+                &segment,
+                if is_start {
+                    LookupStrategy::Indirect
+                } else {
+                    LookupStrategy::Direct
+                },
+            );
+            match (is_terminal, lookup) {
+                (false, Some(Resolved::Type(_))) => {
+                    MESSAGES.report(Message::use_continues_after_type(segment.1));
+                    return None;
+                }
+                (false, Some(Resolved::Module(m))) => {
+                    lookup_scope = self.registry.modules[*m].scope;
+                }
+
+                (true, Some(Resolved::Type(t))) => return Some(*t),
+                (true, Some(Resolved::Module(_))) => {
+                    MESSAGES.report(Message::wrong_path_end(segment, "Type", "Module"));
+                    return None;
+                }
+
+                (_, None) => {
+                    MESSAGES.report(Message::could_not_resolve(segment));
+                    return None;
+                }
+            }
+
+            is_start = false;
+        }
+
+        return None;
+    }
+}

ohdlc/src/ir/stages/flatten_lookup/mod.rs

@@ -2,6 +2,7 @@ use std::mem::MaybeUninit;
 
 use crate::{
     ir::{
+        architectures::RoughArch,
         import_bucket::{ImportBucket, ImportId, LookupStrategy},
         name_lookup::{
             LookupScope, PostFlattenNameLookup, PreFlattenNameLookup, Resolvable, Resolved,
@@ -15,7 +16,7 @@ use crate::{
 use super::rough::types::RoughType;
 
 pub struct FlattenLookupStage<'ir, 'b, 'ast> {
-    pub registry: &'b Registry<RoughType<'ast>>,
+    pub registry: &'b Registry<RoughType<'ast>, RoughArch<'ast>>,
     pub name_lookup: PreFlattenNameLookup,
     pub import_bucket: ImportBucket<'ir>,
     pub resolvables: Vec<ImportId>,

ohdlc/src/ir/stages/mod.rs

@@ -3,3 +3,5 @@ pub mod rough;
 pub mod flatten_lookup;
 
 pub mod refine_types;
+
+pub mod architectures;

ohdlc/src/ir/stages/refine_types/mod.rs

@@ -73,6 +73,7 @@ impl<'ir, 'ast> RefineTypesStage<'ir, '_> {
         })
     }
 
+    // TODO: equal to one in `architectures`, fix duplicate pls
     fn lookup_type(&self, scope: ScopeId, ty: &ast::Type) -> Option<TypeId> {
         let mut lookup_scope = match ty.path.0 .1 {
             ast::PathStart::Root => self.name_lookup.root,

ohdlc/src/ir/stages/rough/mod.rs

@@ -3,6 +3,7 @@ use bumpalo::Bump;
 use crate::{
     ast,
     ir::{
+        architectures::RoughArch,
         import_bucket::{Import, ImportBucket, LookupStrategy},
         modules::Module,
         name_lookup::{PreFlattenNameLookup, Resolvable, Resolved, ScopeId},
@@ -18,7 +19,7 @@ pub mod types;
 
 pub struct RoughStage<'ir, 'b, 'ast> {
     pub arena: &'ir Bump,
-    pub registry: &'b mut Registry<RoughType<'ast>>,
+    pub registry: &'b mut Registry<RoughType<'ast>, RoughArch<'ast>>,
     pub name_lookup: &'b mut PreFlattenNameLookup,
     pub import_bucket: &'b mut ImportBucket<'ir>,
     pub root: &'ast [Spanned<ast::Item<'ast>>],
@@ -38,7 +39,9 @@ impl<'ir, 'ast> RoughStage<'ir, '_, 'ast> {
             ast::Item::Entity(e) => self.introduce_type(scope, e.name, RoughTypeItem::Entity(e)),
             ast::Item::Record(r) => self.introduce_type(scope, r.name, RoughTypeItem::Record(r)),
             ast::Item::Enum(e) => self.introduce_type(scope, e.name, RoughTypeItem::Enum(e)),
-            ast::Item::Arch(_) => {}
+            ast::Item::Arch(a) => {
+                self.registry.architectures.insert(RoughArch(scope, a));
+            }
         }
     }
 

ohdlc/src/main.rs

@@ -9,7 +9,8 @@ use ohdlc::{
         name_lookup::NameLookup,
         registry::Registry,
         stages::{
-            flatten_lookup::FlattenLookupStage, refine_types::RefineTypesStage, rough::RoughStage,
+            architectures::ArchitectureStage, flatten_lookup::FlattenLookupStage,
+            refine_types::RefineTypesStage, rough::RoughStage,
         },
     },
     lexer::Lexer,
@@ -83,11 +84,22 @@ fn main() -> Result<(), ()> {
         Registry {
             modules: registry.modules,
             types: refined_types,
+            architectures: registry.architectures,
         }
     };
 
     println!("{refined_types:#?}");
 
+    {
+        let architectures = ArchitectureStage {
+            arena: &ir_arena,
+            name_lookup: &name_lookup,
+            registry: &refined_types,
+        };
+        architectures.lower();
+        report_messages(&source);
+    };
+
     Ok(())
 }
 

ohdlc/tests/basic.rs

@@ -84,6 +84,7 @@ fn main() {
         Registry {
             modules: registry.modules,
             types: refined_types,
+            architectures: registry.architectures,
         }
     };