Keep analyzing UseDecl blocks after broken UseItems

src/ast/analyze/call.rs

@@ -345,11 +345,9 @@ impl CallName {
             parse::CallName::TypeCast(target) => {
                 scope.resolve(target).map(Self::TypeCast).with_span(from)
             }
-            parse::CallName::Custom(name) => {
-                scope.get_function(name).map(Self::Custom).with_span(from)
-            }
+            parse::CallName::Custom(name) => Ok(Self::Custom(scope.get_function(name, from)?)),
             parse::CallName::ArrayFold(name, size) => {
-                let function = scope.get_function(name).with_span(from)?;
+                let function = scope.get_function(name, from)?;
                 // A function that is used in a array fold has the signature:
                 //   fn f(element: E, accumulator: A) -> A
                 if function.params().len() != 2
@@ -361,7 +359,7 @@ impl CallName {
                 }
             }
             parse::CallName::Fold(name, bound) => {
-                let function = scope.get_function(name).with_span(from)?;
+                let function = scope.get_function(name, from)?;
                 // A function that is used in a list fold has the signature:
                 //   fn f(element: E, accumulator: A) -> A
                 if function.params().len() != 2
@@ -373,7 +371,7 @@ impl CallName {
                 }
             }
             parse::CallName::ForWhile(name) => {
-                let function = scope.get_function(name).with_span(from)?;
+                let function = scope.get_function(name, from)?;
                 // A function that is used in a for-while loop has the signature:
                 //   fn f(accumulator: A, readonly_context: C, counter: u{N}) -> Either<B, A>
                 // where

src/ast/analyze/mod.rs

@@ -41,7 +41,7 @@ mod span_tests {
 
         Function::analyze(&parsed, &ResolvedType::unit(), &mut scope).expect("function analyzes");
         let function = scope
-            .get_function(parsed.name())
+            .get_function(parsed.name(), &parsed)
             .expect("function is registered in scope");
 
         assert_eq!(function.span().to_slice(source), Some(source));

src/ast/analyze/program.rs

@@ -118,7 +118,7 @@ impl AbstractSyntaxTree for Item {
                 Function::analyze(function, ty, scope).map(Self::Function)
             }
             parse::Item::Use(use_decl) => {
-                scope.resolve_use(use_decl).with_span(use_decl)?;
+                scope.resolve_use(use_decl);
                 Ok(Self::Use)
             }
             parse::Item::EnumDeclaration(decl) => {

src/ast/scope/mod.rs

@@ -258,8 +258,12 @@ impl Scope {
         self.modules.path()
     }
 
-    pub(super) fn resolve_use(&mut self, use_decl: &UseDecl) -> Result<(), Error> {
-        self.modules.resolve_use(use_decl)
+    pub(super) fn resolve_use(&mut self, use_decl: &UseDecl) {
+        let span = Span::from(use_decl);
+
+        for error in self.modules.resolve_use(use_decl) {
+            self.report(error.with_span(span));
+        }
     }
 
     pub(super) fn get_alias(&self, name: &AliasName) -> Result<ResolvedType, Error> {
@@ -288,8 +292,16 @@ impl Scope {
         self.modules.insert_function(name, visibility, function)
     }
 
-    pub(super) fn get_function(&self, name: &FunctionName) -> Result<CustomFunction, Error> {
-        self.modules.get_function(name)
+    pub(super) fn get_function(
+        &self,
+        name: &FunctionName,
+        span: impl Into<Span>,
+    ) -> Result<CustomFunction, Failure> {
+        match self.modules.get_function(name) {
+            Ok(function) => Ok(function),
+            Err(_) if self.modules.is_poisoned(name.as_str()) => Err(Failure::Reported),
+            Err(error) => Err(error.with_span(span.into()).into()),
+        }
     }
 
     /// Insert a variable into the current block.