Fix errors not being reported from flattening

CHANGELOG.md

@@ -1,2 +1,3 @@
 # Changelog
 - Standard library is shipped with the compiler now in the [stl/](stl/) directory. 
+- Changed template definition and usage syntax to named arguments in `#()` instead of `::<>` (See [philosophy/template_troubles.md](philosophy/template_troubles.md))

src/errors.rs

@@ -68,6 +68,7 @@ impl ErrorStore {
         self.did_error = checkpoint.1;
     }
 
+    /// Returns true if no errors have been reported
     pub fn is_untouched(&self) -> bool {
         self.errors.is_empty()
     }
@@ -112,7 +113,7 @@ impl<'linker> ErrorCollector<'linker> {
 
     /// Turn the collector back into a [ErrorStore]
     pub fn into_storage(self) -> ErrorStore {
-        self.error_store.into_inner()
+        self.error_store.replace(ErrorStore::new())
     }
 
     fn assert_span_good(&self, span: Span) {
@@ -167,6 +168,14 @@ impl<'linker> ErrorCollector<'linker> {
     }
 }
 
+impl<'l> Drop for ErrorCollector<'l> {
+    fn drop(&mut self) {
+        if !self.error_store.borrow().is_untouched() {
+            panic!("ErrorCollector should have been emptied!");
+        }
+    }
+}
+
 pub struct ErrorReference<'ec> {
     err_collector: &'ec ErrorCollector<'ec>,
     pos: usize,

src/flattening/flatten.rs

@@ -312,11 +312,12 @@ impl<'l, 'errs : 'l> FlatteningContext<'l, 'errs> {
                         (TemplateInputKind::Type(_), TemplateArgKind::Type(_)) 
                         | (TemplateInputKind::Generative(_), TemplateArgKind::Value(_)) => {
                             // Correct pairing
-                            if let Some(prev) = &template_arg_map[id] {
+                            let elem = &mut template_arg_map[id];
+                            if let Some(prev) = elem {
                                 self.errors.error(name_span, format!("'{name}' has already been defined previously"))
                                     .info_same_file(prev.name_span, "Defined here previously");
                             } else {
-                                template_arg_map[id] = Some(TemplateArg { name_span, kind: template_arg });
+                                *elem = Some(TemplateArg { name_span, kind: template_arg });
                             }
                         }
                         (TemplateInputKind::Type(_), TemplateArgKind::Value(_)) => {
@@ -1465,8 +1466,8 @@ pub fn flatten_all_modules(linker: &mut Linker) {
                 assert!(context.ports_to_visit.is_empty());
 
                 let instructions = context.instructions;
-                
-                match file_obj {
+
+                let link_info : &mut LinkInfo = match file_obj {
                     NameElem::Module(module_uuid) => {
                         let md = &mut linker.modules[module_uuid];
                         // Set all declaration_instruction values
@@ -1490,6 +1491,7 @@ pub fn flatten_all_modules(linker: &mut Linker) {
                             }
                         }
                         md.instructions = instructions;
+                        &mut md.link_info
                     }
                     NameElem::Type(type_uuid) => {
                         let typ = &mut linker.types[type_uuid];
@@ -1515,11 +1517,15 @@ pub fn flatten_all_modules(linker: &mut Linker) {
                             }
                         }
                         typ.instructions = instructions;
+                        &mut typ.link_info
                     }
                     NameElem::Constant(const_uuid) => {
                         todo!("TODO Constant flattening")
                     }
-                }
+                };
+
+                link_info.resolved_globals = errors_globals.1.into_inner();
+                link_info.errors = errors_globals.0.into_storage();
             });
         });
         span_debugger.defuse();

test.sus

@@ -833,7 +833,7 @@ module replicate #(T, int NUM_REPLS) {
 }
 
 module use_replicate {
-	replicate #(NUM_REPLS: 50, T: type bool) a
+	replicate #(NUM_REPLS: 50, NUM_REPLS: 30, T: type bool) a
 	replicate #(NUM_REPLS: 20, T: type int[30]) b
 }
 

tinyTestFile.sus

@@ -1,4 +1,18 @@
 
+module replicatee #(T, int NUM_REPLS) {
+	interface replicatee: T data -> T[NUM_REPLS] result
+
+	for int i in 0..NUM_REPLS {
+		result[i] = data
+	} 
+}
+
+module use_replicatee {
+	replicatee #(NUM_REPLS: 50, T: type bool) a
+
+	bool[50] repls = a(true)
+}
+
 extern module TestExtern {
 	input int in_a'3