Ensure that we accurately compute our external function dependencies.

It was possible to not have a reference to an 'external used function' after
execution native_ast_to_llvm conversion because some code pathways don't get
exercised. The linker downstream cannot now this, and would complain if the
value wasn't present.

Author: braxtonmckee

typed_python/compiler/native_compiler/native_ast_to_llvm.py

@@ -14,6 +14,7 @@
 
 from typed_python.compiler.native_compiler.module_definition import ModuleDefinition
 from typed_python.compiler.native_compiler.typed_llvm_value import TypedLLVMValue
+from typed_python.compiler.native_compiler.native_ast_analysis import extractNamedCallTargets
 from typed_python.compiler.native_compiler.native_ast_to_llvm_function_converter import (
     type_to_llvm_type,
     FunctionConverter,
@@ -292,7 +293,6 @@ def add_functions(self, names_to_definitions):
 
         globalDefinitions = {}
         globalDefinitionsLlvmValues = {}
-        usedExternalFunctions = set()
 
         while names_to_definitions:
             for name in sorted(names_to_definitions):
@@ -322,8 +322,7 @@ def add_functions(self, names_to_definitions):
                             builder,
                             arg_assignments,
                             definition.output_type,
-                            external_function_references,
-                            usedExternalFunctions
+                            external_function_references
                         )
 
                         func_converter.setup()
@@ -367,6 +366,15 @@ def add_functions(self, names_to_definitions):
             args=[native_ast.Void.pointer().pointer()]
         )
 
+        usedExternalFunctions = [
+            callTarget.name for callTarget in extractNamedCallTargets(functionsDefinedHere)
+            if not callTarget.external and callTarget.name not in functionsDefinedHere
+        ]
+
+        for name in usedExternalFunctions:
+            if name not in self._function_definitions:
+                raise Exception(f"Somehow we depend on {name} but have no definition for it")
+
         return ModuleDefinition(
             str(module),
             functionTypes,

typed_python/compiler/native_compiler/native_ast_to_llvm_function_converter.py

@@ -567,8 +567,7 @@ def __init__(self,
                  builder,
                  arg_assignments,
                  output_type,
-                 external_function_references,
-                 usedExternalFunctions
+                 external_function_references
                  ):
         self.function = function
 
@@ -582,7 +581,6 @@ def __init__(self,
         self.arg_assignments = arg_assignments
         self.output_type = output_type
         self.external_function_references = external_function_references
-        self.usedExternalFunctions = usedExternalFunctions
         self.tags_initialized = {}
         self.stack_slots = {}
 
@@ -722,9 +720,6 @@ def namedCallTargetToLLVM(self, target):
                 ):
                     func = self.converter.repeatFunctionInModule(target.name, self.module)
                 else:
-                    # this function is defined in another module.
-                    self.usedExternalFunctions.add(target.name)
-
                     if target.name not in self.external_function_references:
                         self.external_function_references[target.name] = \
                             llvmlite.ir.Function(self.module, func.function_type, func.name)