Generate IR per-module for loaded modules (#299)

The basic idea here is that for each module that gets loaded via `import`, we should also generate the initial IR for the declarations in that module at the time it gets loaded.

Furthermore, when we generate initial IR for a module, we will only generate IR *declarations* (not *definitions*) for any functions/variables in modules it imports.
Later, when cloning IR to begin code generation for an entry point, we will effectively "link" all of the loadedm modules together, so that a given global value can get its definition from any of the IR modules present.

- Change the `loadedModulesList` and related data structures to hold a new `LoadedModule` type, instead of just the AST (and then have a `LoadedModule` own both the AST and the IR module)

- Share some logic between the `import` and `#import` cases, so that we always try to generate IR for modules we load.

- Make sure that IR generation always gets skipped if the command-line flags tell us not to use the IR.

- A few small fixups for cases that didn't arise in IR lowering so far, but come up when we try to actually generate IR for things like the stdlib.

There are some notable gaps in this work right now:

- The stdlib modules are exempted from this behavior; we always generate IR for stdlib functions in any user module that calls them. This is just a workaround for the fact that the stdlib modules don't show up in the list of imported modules right now.

- We don't currently have logic that does the "linking" step for global variables like we do for functions. We really need to look up the symbols with the same mangled name, and favor any one of them that has a definition (if there is one)

- Similarly, the handling of witness tables is incomplete. During initial IR generation, we should probably be generating empty witness tables for any conformances that were declared in other modules (but are being used locally in this module), and then the "linking" step should favor non-empty witness tables over empty ones.

Still, all the test cases pass with the code like this, and this seems like an important step in the right direction.

1 files changed, 2 insertions, 2 deletions

diff --git a/source/slang/parameter-binding.cpp b/source/slang/parameter-binding.cpp
index 0daa2abc7..b97c174fc 100644
--- a/source/slang/parameter-binding.cpp
+++ b/source/slang/parameter-binding.cpp
@@ -1648,9 +1648,9 @@ static void collectParameters(
     }
 
     // Now collect parameters from loaded modules
-    for (auto& module : request->loadedModulesList)
+    for (auto& loadedModule : request->loadedModulesList)
     {
-        collectModuleParameters(context, module.Ptr());
+        collectModuleParameters(context, loadedModule->moduleDecl.Ptr());
     }
 }