Split compilation into multiple passes

[Balint-R]

@KavinSatheeskumar suggested that it might be a good idea to split the compilation process into multiple passes, where each pass does one type of thing. This is supposedly how most other compilers work, and could help with how PyDSL code is organized.

Some possible passes include:

• Name resolution
• Type inference and type checking
• Adding empty return statements if no return statement is present
• Main pass which does the rest of the logic

One concern I have is that some parts of parsing the syntax are fundamentally recursive, so a lot of the logic would still have to stay in one pass. Also what happens if we find that something we already split into a pass actually has some recursive interaction with other passes? They would need to be moved back to the main pass, and it could be a lot of effort to do this, so I am not certain whether it will be more or less maintainable.

#51 is relevant.

[KavinSatheeskumar]

Note that this also allows for dataflow analysis, which mayy be useful in addressing #33

[Balint-R]

Conclusion from yesterday's discussion:

• This is probably a good idea for organization, so we should try to implement this, splitting the compilation pipeline into several passes.
• You should think carefully about how you want to structure the new code, since the whole point of this is to make the codebase more organized and easy to work with.
• We can start by creating a pass system, and initially there is only one pass, ToMLIR.
• Then, we can extract features one by one, creating a new pass for each one.
• We will likely want to create our own AST. Maybe a solution is to use the existing node types provided by the AST library, and add new subclasses whenever there is something new we need to be able to represent.

Some advantages of a pass system:

• Better organized code.
• Better error messages.
• Can emit multiple errors at the same time, instead of always failing on the first error.
• Some features are much easier to support with a pass system.
• Can parallelize for passes that operate on individual functions (low priority).