Selfhost Lexer / IO Interfaces / Bugfix

Makefile

@@ -74,12 +74,12 @@ testsuite: build
 		-d tests \
 		--output ./tmp/tests \
 		--compiler $(COMPILER) \
-		--flags "--stdlib=$(STDLIB) --quiet"
+		--flags "--stdlib=$(STDLIB) --quiet --jobs 1"
 
 testsuite-fail: build
 	$(PY_CMD) ./tests/test_suite.py \
 		-d tests \
 		--output ./tmp/tests \
 		--compiler $(COMPILER) \
 		--fail \
-		--flags "--stdlib=$(STDLIB) --quiet"
+		--flags "--stdlib=$(STDLIB) --quiet --jobs 1"

crates/cyrusc_analyzer/src/analyze/block_stmt.rs

@@ -12,7 +12,7 @@ impl<'a> AnalysisContext<'a> {
         let mut terminated = false;
 
         let stmts = std::mem::take(&mut block_stmt.stmts);
-        let mut final_stmts = Vec::with_capacity(block_stmt.stmts.len());
+        let mut final_stmts = Vec::with_capacity(stmts.len());
 
         for mut stmt in stmts {
             let stmt_state = self.analyze_stmt(&mut stmt);

crates/cyrusc_analyzer/src/analyze/control_flow.rs

@@ -373,7 +373,19 @@ impl<'a> AnalysisContext<'a> {
 
                     match enum_variant {
                         TypedEnumVariant::Tuple { fields, .. } => {
-                            if fields.len() != items.len() {}
+                            if fields.len() != items.len() {
+                                this.reporter.report(Diag {
+                                    level: DiagLevel::Error,
+                                    kind: Box::new(AnalyzerDiagKind::EnumVariantArgCountMismatch {
+                                        variant_name: ident.as_string(),
+                                        expected: fields.len() as u32,
+                                        provided: items.len() as u32,
+                                    }),
+                                    loc: Some(pattern.loc),
+                                    hint: None,
+                                });
+                                return;
+                            }
 
                             *exporting_pattern_count += 1;
 
@@ -414,11 +426,7 @@ impl<'a> AnalysisContext<'a> {
                 }
 
                 // .StructVariant { x, y, .. }
-                TypedSwitchCasePatternKind::EnumStructVariant {
-                    ident,
-                    items,
-                    has_rest: _,
-                } => {
+                TypedSwitchCasePatternKind::EnumStructVariant { ident, items, has_rest } => {
                     let Some(enum_variant) = find_variant(inst_enum_decl, ident) else {
                         this.reporter.report(Diag {
                             level: DiagLevel::Error,
@@ -449,6 +457,20 @@ impl<'a> AnalysisContext<'a> {
                         TypedEnumVariant::Struct { fields, .. } => {
                             let mut has_error = false;
 
+                            if !has_rest && fields.len() != items.len() {
+                                this.reporter.report(Diag {
+                                    level: DiagLevel::Error,
+                                    kind: Box::new(AnalyzerDiagKind::EnumVariantArgCountMismatch {
+                                        variant_name: ident.as_string(),
+                                        expected: fields.len() as u32,
+                                        provided: items.len() as u32,
+                                    }),
+                                    loc: Some(pattern.loc),
+                                    hint: None,
+                                });
+                                return;
+                            }
+
                             for item in items {
                                 let exists = fields.iter().any(|field| field.name == item.name);
 

crates/cyrusc_analyzer/src/analyze/enum_stmt.rs

@@ -17,7 +17,7 @@ impl<'a> AnalysisContext<'a> {
     pub(crate) fn analyze_enum_stmt(&mut self, enum_stmt: &mut TypedEnumStmt) {
         let mut enum_decl = self.decl_tables.enum_decl(enum_stmt.enum_decl_id);
 
-        if enum_stmt.is_generic() {
+        if !enum_stmt.is_generic() {
             let object_type = SemaType::Named(NamedType {
                 type_decl_id: TypeDeclID::Enum(enum_stmt.enum_decl_id),
                 type_args: TypedTypeArgs::new(),
@@ -58,19 +58,19 @@ impl<'a> AnalysisContext<'a> {
 
         self.analyze_generic_bounds(&enum_decl.generic_params);
 
+        let object_type_decl_id = TypeDeclID::Enum(enum_decl_id);
+
+        if !enum_decl.is_generic() {
+            self.analyze_object_methods(object_type_decl_id, &enum_decl.methods);
+        }
+
         self.analyze_object_implements_interfaces(
             &object_name,
             enum_decl.is_generic(),
             &enum_decl.impls,
             &enum_decl.methods,
         );
 
-        let object_type_decl_id = TypeDeclID::Enum(enum_decl_id);
-
-        if !enum_decl.is_generic() {
-            self.analyze_object_methods(object_type_decl_id, &enum_decl.methods);
-        }
-
         self.decl_tables.with_enum_decl_mut(enum_decl_id, |_enum_decl| {
             _enum_decl.variants = enum_decl.variants.clone();
         });

crates/cyrusc_analyzer/src/analyze/interfaces.rs

@@ -23,7 +23,14 @@ impl<'a> AnalysisContext<'a> {
         let mut methods: Vec<String> = Vec::new();
 
         for (_, method_decl_id) in interface.methods.iter() {
-            let method_decl = self.decl_tables.method_decl(*method_decl_id);
+            let mut method_decl = self.decl_tables.method_decl(*method_decl_id);
+
+            self.analyze_method_decl(TypeDeclID::Interface(interface.interface_decl_id), &mut method_decl);
+
+            self.decl_tables.with_method_decl_mut(*method_decl_id, |_method_decl| {
+                *_method_decl = method_decl.clone();
+            });
+
             let func_decl = method_decl.func_decl;
 
             let params_start = if let Some(self_modifier) = func_decl.params.get_self_modifier() {
@@ -137,6 +144,7 @@ impl<'a> AnalysisContext<'a> {
 
             for (_, method_decl_id) in interface_decl.methods.iter() {
                 let interface_method_decl = self.decl_tables.method_decl(*method_decl_id);
+
                 let func_decl = instantiate_method_decl(
                     &interface_method_decl,
                     &interface_decl.generic_params,
@@ -232,7 +240,6 @@ impl<'a> AnalysisContext<'a> {
 
                 for (_, method_decl_id) in interface_decl.methods.iter() {
                     // interface method
-
                     let interface_method_decl = &mut this.decl_tables.method_decl(*method_decl_id).func_decl;
 
                     let self_modifier = interface_method_decl.params.get_self_modifier_mut().unwrap();
@@ -242,7 +249,6 @@ impl<'a> AnalysisContext<'a> {
                     interface_method_decl.ret_type = this.substitute_type(&interface_method_decl.ret_type);
 
                     // object method
-
                     let Some(method_decl_id) = method_decls.get(&interface_method_decl.name) else {
                         continue;
                     };

crates/cyrusc_analyzer/src/analyze/methods.rs

@@ -3,6 +3,7 @@
 
 use crate::{context::AnalysisContext, infer::InferCtx};
 use cyrusc_typed_ast::{
+    debug_assert_func_decl_resolved,
     decls::{MethodDecl, MethodDeclID, MethodDecls},
     stmts::{TypedFuncParamKind, TypedTypeArgs},
     types::{NamedType, SemaType, TypeDeclID},
@@ -16,6 +17,9 @@ impl<'a> AnalysisContext<'a> {
 
             self.analyze_method_decl(object_type_decl_id, &mut method_decl);
 
+            #[cfg(debug_assertions)]
+            debug_assert_func_decl_resolved!(&method_decl.func_decl);
+
             self.decl_tables.with_method_decl_mut(*method_decl_id, |_method_decl| {
                 *_method_decl = method_decl;
             });
@@ -42,7 +46,7 @@ impl<'a> AnalysisContext<'a> {
         // If the method is non-generic, eagerly lower all SelfType occurrences
         // to the concrete object type. Generic methods defer SelfType substitution
         // to the call-site via the instantiated generic environment.
-        if !method_decl.func_decl.is_generic() {
+        if !method_decl.func_decl.is_generic() && !object_type_decl_id.is_interface() {
             let concrete_self_type = SemaType::Named(NamedType {
                 type_decl_id: object_type_decl_id,
                 type_args: TypedTypeArgs::new(),
@@ -90,10 +94,6 @@ impl<'a> AnalysisContext<'a> {
             match param_kind {
                 TypedFuncParamKind::FuncParam(func_param) => {
                     func_param.ty = self.substitute_self_type(func_param.ty.clone(), concrete_self_type);
-
-                    if let Some(infer) = &self.func_env.infer {
-                        func_param.ty = infer.resolve(&func_param.ty);
-                    }
                 }
                 TypedFuncParamKind::SelfModifier(self_modifier) => {
                     self_modifier.ty = self.substitute_self_type(self_modifier.ty.clone(), concrete_self_type);
@@ -106,6 +106,12 @@ impl<'a> AnalysisContext<'a> {
             }
         }
 
+        if let Some(ret_type) =
+            self.normalize_sema_type(method_decl.func_decl.ret_type.clone(), method_decl.func_decl.loc, 0)
+        {
+            method_decl.func_decl.ret_type = ret_type;
+        }
+
         let mut substituted_ret_type =
             self.substitute_self_type(method_decl.func_decl.ret_type.clone(), concrete_self_type);
 

crates/cyrusc_analyzer/src/analyze/struct_stmt.rs

@@ -58,18 +58,18 @@ impl<'a> AnalysisContext<'a> {
 
         self.analyze_generic_bounds(&struct_decl.generic_params);
 
+        let object_type_decl_id = TypeDeclID::Struct(struct_decl_id);
+
+        if !struct_decl.is_generic() {
+            self.analyze_object_methods(object_type_decl_id, &struct_decl.methods);
+        }
+
         self.analyze_object_implements_interfaces(
             &object_name,
             struct_decl.is_generic(),
             &struct_decl.impls,
             &struct_decl.methods,
         );
-
-        let object_type_decl_id = TypeDeclID::Struct(struct_decl_id);
-
-        if !struct_decl.is_generic() {
-            self.analyze_object_methods(object_type_decl_id, &struct_decl.methods);
-        }
     }
 
     fn analyze_struct_fields(&mut self, struct_decl_id: StructDeclID, struct_fields: &mut [TypedStructField]) {

crates/cyrusc_analyzer/src/analyze/union_stmt.rs

@@ -54,18 +54,18 @@ impl<'a> AnalysisContext<'a> {
 
         self.analyze_generic_bounds(&union_decl.generic_params);
 
+        let object_type_decl_id = TypeDeclID::Union(union_decl_id);
+
+        if !union_decl.is_generic() {
+            self.analyze_object_methods(object_type_decl_id, &union_decl.methods);
+        }
+
         self.analyze_object_implements_interfaces(
             &object_name,
             union_decl.is_generic(),
             &union_decl.impls,
             &union_decl.methods,
         );
-
-        let object_type_decl_id = TypeDeclID::Union(union_decl_id);
-
-        if !union_decl.is_generic() {
-            self.analyze_object_methods(object_type_decl_id, &union_decl.methods);
-        }
     }
 
     fn analyze_union_fields(&mut self, union_decl_id: UnionDeclID, union_fields: &mut [TypedUnionField]) {

crates/cyrusc_analyzer/src/analyze/vars.rs

@@ -61,7 +61,7 @@ impl<'a> AnalysisContext<'a> {
         };
 
         if let Some(ty) = &global_var.ty {
-            if !self.validate_variable_type(ty, global_var.expr.is_some(), global_var.loc) {
+            if !self.validate_variable_type(ty, global_var.expr.is_some() || global_var.is_undef, global_var.loc) {
                 return;
             }
 
@@ -154,7 +154,7 @@ impl<'a> AnalysisContext<'a> {
                 self.report_const_qualified_type_assigned_to_non_const_variable(var.loc);
             }
 
-            if !self.validate_variable_type(ty, var.rhs.is_some(), var.loc) {
+            if !self.validate_variable_type(ty, var.rhs.is_some() || var.is_undef, var.loc) {
                 return;
             }
 

crates/cyrusc_analyzer/src/diagnostics.rs

@@ -49,9 +49,14 @@ pub enum AnalyzerDiagKind {
     #[error("Cannot infer dynamic interface type.")]
     CannotInferDynamicInterfaceType,
 
-    #[error("Cannot apply 'dynamic' to an already dynamic value.")]
+    #[error("Cannot apply dynamic to an already dynamic value.")]
     InvalidMultipleDynamicType,
 
+    #[error("Cannot apply dynamic to type '{type_name}'.")]
+    InvalidDynamicType {
+        type_name: String
+    },
+
     #[error(
         "Method '{method_name}' requires mutable access to 'self', but instance of type '{type_name}' is declared 'const'."
     )]
@@ -470,6 +475,9 @@ pub enum AnalyzerDiagKind {
     #[error("Symbol '{symbol_name}' is not an enum.")]
     NonEnumSymbol { symbol_name: String },
 
+    #[error("Symbol '{symbol_name}' is not a type.")]
+    NonTypeSymbol { symbol_name: String },
+
     #[error("Cannot use {elements} elements in an array of size {expected}.")]
     ArrayElementsCountMismatch { elements: u32, expected: u32 },
 

crates/cyrusc_analyzer/src/env/generic_env.rs

@@ -78,7 +78,14 @@ impl GenericEnv {
     #[inline]
     pub fn substitute_sema_type(&self, ty: &SemaType) -> SemaType {
         match ty {
-            SemaType::Unresolved(_) | SemaType::InferVar(_) | SemaType::Plain(_) | SemaType::Placeholder => ty.clone(),
+            SemaType::SelfType(self_type) => SemaType::SelfType(self_type.clone()),
+
+            SemaType::Err(_)
+            | SemaType::Unresolved(_)
+            | SemaType::InferVar(_)
+            | SemaType::Plain(_)
+            | SemaType::Placeholder => ty.clone(),
+
             SemaType::Named(named_type) => {
                 let type_args = named_type
                     .type_args
@@ -154,9 +161,6 @@ impl GenericEnv {
                 Some(ty) => ty.clone(),
                 None => ty.clone(),
             },
-            SemaType::SelfType(self_type) => SemaType::SelfType(self_type.clone()),
-
-            SemaType::Err(_) => ty.clone(),
         }
     }
 }

crates/cyrusc_analyzer/src/monomorph.rs

@@ -517,7 +517,7 @@ impl<'a> AnalysisContext<'a> {
                 }
             }
             TypedExprKind::EnumInit(enum_init) => match &mut enum_init.arg {
-                TypedEnumInitArgs::Unit => todo!(),
+                TypedEnumInitArgs::Unit => {}
                 TypedEnumInitArgs::Tuple(elements) => {
                     for element in elements {
                         self.specialize_expr(element, decl_map);

crates/cyrusc_analyzer/src/normalizer.rs

@@ -183,9 +183,21 @@ impl<'a> AnalysisContext<'a> {
         indirection: u8,
     ) -> Option<SemaType> {
         let ty = match unresolved_type {
-            UnresolvedType::Decl(symbol_id) => self
-                .lookup_symbol_as_decl_id(symbol_id)
-                .and_then(|decl_id| self.resolve_symbol_type(decl_id, loc, indirection))?,
+            UnresolvedType::Decl(symbol_id) => self.lookup_symbol_as_decl_id(symbol_id).and_then(|decl_id| {
+                if decl_id.as_type_decl_id().is_none() {
+                    let symbol_name = self.formatter.format_decl(decl_id);
+
+                    self.reporter.report(Diag {
+                        level: DiagLevel::Error,
+                        kind: Box::new(AnalyzerDiagKind::NonTypeSymbol { symbol_name }),
+                        loc: Some(loc),
+                        hint: None,
+                    });
+                    return None;
+                }
+
+                self.resolve_symbol_type(decl_id, loc, indirection)
+            })?,
 
             UnresolvedType::GenericInst {
                 base_symbol_id,
@@ -282,7 +294,7 @@ impl<'a> AnalysisContext<'a> {
         let elements: Vec<_> = tuple_type
             .elements
             .into_iter()
-             .filter_map(|(ty, loc)| {
+            .filter_map(|(ty, loc)| {
                 self.normalize_sema_type(ty, tuple_type.loc, indirection)
                     .map(|ty| (ty, loc))
             })
@@ -299,7 +311,6 @@ impl<'a> AnalysisContext<'a> {
         }))
     }
 
-    // TODO: Implement slices.
     fn normalize_array_capacity(
         &mut self,
         mut array: TypedArrayType,
@@ -378,7 +389,7 @@ impl<'a> AnalysisContext<'a> {
         for type_arg in type_args.iter_mut() {
             match type_arg {
                 TypedTypeArg::Type(ty, loc) => {
-                    *ty = match self.normalize_and_check_type_formation(ty.clone(), *loc, indirection) {
+                    *ty = match self.normalize_sema_type(ty.clone(), *loc, indirection) {
                         Some(sema_type) => sema_type,
                         None => continue,
                     };