Show an error when a source file fails to parse

Previously, if a source file failed to parse, no symbols would be
returned and symbol resolution would continue as normal. This would
obscure the source of any errors, as well as the fact that any error
had occurred at all.

We don't want all errors in all source files to be printed at symbol
resolution time, because this could bury any errors in the actual
program being assembled with potentially irrelevant library errors,
and errors in the program being assembled will be printed all over
again once a merged source file has been produced.

Instead, we allow the parser function to return a None value if the
file could not be parsed, and a single line is printed as a warning
for every library file that failed to parse.

1 files changed, 23 insertions, 16 deletions

diff --git a/src/resolver.rs b/src/resolver.rs
index 2b49055..8d3a16d 100644
--- a/src/resolver.rs
+++ b/src/resolver.rs
@@ -43,12 +43,20 @@ impl Resolver {
         let source_id = self.source_units.len();
         use std::mem::take;
 
-        info!("Including source file at {:?}", source_unit.main.path);
-        self.include_symbols(take(&mut source_unit.main.symbols), source_id, SourceRole::Main);
+        info!("Including source unit at {:?}", source_unit.main.path);
+        if let Some(symbols) = &mut source_unit.main.symbols {
+            self.include_symbols(take(symbols), source_id, SourceRole::Main);
+        }
         if let Some(head) = &mut source_unit.head {
-            self.include_symbols(take(&mut head.symbols), source_id, SourceRole::Head); }
+            if let Some(symbols) = &mut head.symbols {
+                self.include_symbols(take(symbols), source_id, SourceRole::Head);
+            }
+        }
         if let Some(tail) = &mut source_unit.tail {
-            self.include_symbols(take(&mut tail.symbols), source_id, SourceRole::Tail); }
+            if let Some(symbols) = &mut tail.symbols {
+                self.include_symbols(take(symbols), source_id, SourceRole::Tail);
+            }
+        }
 
         match parent_id {
             Some(parent_id) => match self.source_units.get_mut(parent_id) {
@@ -153,19 +161,18 @@ impl Resolver {
     /// Return the ID of a source unit that contains an unresolved reference
     /// to a symbol defined by this unit.
     fn unit_resolved_by_unit(&self, source_unit: &SourceUnit) -> Option<usize> {
-        if let Some(id) = self.unit_resolved_by_symbol(&source_unit.main.symbols) {
-            return Some(id);
-        }
-        if let Some(head) = &source_unit.head {
-            if let Some(id) = self.unit_resolved_by_symbol(&head.symbols) {
-                return Some(id);
-            }
-        }
-        if let Some(tail) = &source_unit.tail {
-            if let Some(id) = self.unit_resolved_by_symbol(&tail.symbols) {
-                return Some(id);
-            }
+        macro_rules! return_resolved_unit {
+            ($file:expr) => {
+                if let Some(symbols) = &$file.symbols {
+                    if let Some(id) = self.unit_resolved_by_symbol(&symbols) {
+                        return Some(id);
+                    }
+                }
+            };
         }
+        return_resolved_unit!(&source_unit.main);
+        if let Some(head) = &source_unit.head { return_resolved_unit!(&head) }
+        if let Some(tail) = &source_unit.tail { return_resolved_unit!(&tail) }
         return None;
     }