Description

Compile time increases drastically when certain functionality and dependencies are added.

For example, adding toUint() to each int type and to256() to int128/uint128 types results in a huge increase in time to compile.

Troubleshooting

Flattening the src/UnitTypes.sol file results in a big (~5000 lines of code) contract but removing the functions and dependencies that balloon compile time only slightly reduce the flatten contract size (by a few hundred lines). However, removing the latter results in significantly shorter compile times.

Internal Discussion

Confirmed: at any commit I have checked out and tried compiling in the past (this one and this one too), compile time is very long (as expected).

However, I found that if you deleted the test/ directory, compile time goes down to <1s.

I used forge flatten src/UnitTypes.sol --output flattened to force all of the imports into one file just to see what that looked like. As expected, the file was ~5000 lines (4 directories * 6 directories * ~200 lines per nested directory == 4800). It is interesting to check out yourself bc when it flattens everything; it enumerates each add so you end up seeing:

using {
    add_23 as +,
    and2_23 as &,
    sub_23 as -,
    (...)
} for USDPerQuantoUint256 global;

What is more interesting is that looking at the latest commit (which compiles and works ~quickly <10s), the flattened output is still nearly 5000 lines.

So, what is going on?

What I suspect (and hopefully will confirm) is that since everything is file level (i.e., none of this code is in a contract or library outside of the known SafeCasting), each time there is a dependency in the src/ contracts, the amount of "work" to resolve it increases exponentially. So, let's say we import BaseInt128, which then imports BaseInt256, which then imports BaseQuantoPerUSDInt256, and so on; it eventually resolves everything (as we see in the flattened contract), but it does this without "caching" it. Also, the dependency graph doesn't increase linearly when you add a single dependency; it is more like a quadratic, which is why we see the compile time balloon quite suddenly.

There are still a bunch of questions I have about this; however, what I think might actually work is this:

Define each type (i.e. BaseInt128) as before, however, remove all outside dependencies (i.e. do not define yet how a BaseInt128 type interacts with a USDInt128 type in the helper file. Once this has been done for each type, then define a library (or libraries) that specify differing type interactions. Call this Interactions or something. The library will, much more efficiently, manage dependencies and not result in the crazy dependency tangle that has to be resolved over and over.

(also, a lot of these "intuitions" are also coming from me removing things here and there, keeping a single test, etc etc, and testing out compile times)