Code Coverage

[xmnlab]

Currently, just 59% of the code is covered by the tests.
We need to increase it to above of 90%.

---------- coverage: platform linux, python 3.13.0-final-0 -----------
Name                               Stmts   Miss  Cover   Missing
----------------------------------------------------------------
src/irx/__init__.py                    3      0   100%
src/irx/builders/__init__.py           0      0   100%
src/irx/builders/base.py              78     19    76%   28, 33, 38, 43, 48, 53, 58, 63, 68, 73, 78, 83, 88, 93, 98, 103, 108, 148, 153
src/irx/builders/llvmliteir.py       401    162    60%   25-26, 34-35, 65, 67, 69, 72-77, 171, 177, 209, 222-243, 252, 275-282, 286-293, 299, 311, 329-393, 398-493, 506, 535, 542-545, 551, 561-562, 589, 610-627, 637, 681-682, 687, 692-708, 716, 725, 732-736, 786
src/irx/builders/symbol_table.py      23     23     0%   3-37
----------------------------------------------------------------
TOTAL                                505    204    60%

Required test coverage of 52% reached. Total coverage: 59.60%

[xmnlab]

currently it is 83% covered, a good coverage right now would be something about 90%

ref https://github.com/arxlang/irx/actions/runs/18207067265/job/51839875425?pr=106#step:5:225

[Jaskirat-s7]

Hi, I'd like to work on this issue. I ran a coverage report and analyzed where the gaps are.

Currently llvmliteir.py sits at 82% coverage (227 lines missing out of 1276). base.py and init.py are already at 100%. The overall total is 83%.

After going through the missing lines, the biggest chunk of untested code (~130 lines) is the vector math handling inside BinaryOp — things like scalar-vector promotion, vector addition/subtraction/multiplication/division, and FMA. There are literally zero tests for any of that right now.

Beyond that, there are smaller gaps in string helper stubs (dead code with external linkage), variable assignment error branches, and some unary operator edge cases.

My plan to get this above 90%:

1. Add a tests/test_vector_math.py covering vector binary ops, scalar-vector promotion, and FMA — this alone should cover the largest gap.
2. Add edge case tests for assignment validation and unary ops to pick up the remaining uncovered branches.
3. Run pytest --cov to confirm we've crossed 90%.

I've branched off main and started working on this. Let me know if this approach works!

[Jaskirat-s7]

Hey @yuvimittal @xmnlab ,

I've added 53 new tests across 3 new test files (test_coverage_boost.py,test_coverage_extra.py, and test_coverage_more.py) to target the uncovered lines in llvmliteir.py. The coverage has improved from 82% to 85% (covering 1081 out of 1276 lines), and all 204 tests are passing.
However, I'm finding it difficult to reach the 90% goal because the remaining -195 missing lines are mostly unreachable through the current AST visitor tests. Specifically:~130 lines are vector math operations (is_vector, splat_scalar
,etc.), but astx currently has no vector types to trigger these paths during lowering.
-70 lines are string helper function stubs (_create_string_concat_function, etc.) which appear to be dead code / unused right now.
Given that these paths can't be reached by passing AST nodes into the visitor, do you have any suggestions on how to test them? Should I write unit tests that call these visitor methods directly , or should we exclude these specific blocks from the coverage requirement for now?

[Jaskirat-s7]

@xmnlab @yuvimittal ,Just wanted to give an update: I've managed to boost the test coverage for llvmliteir.py from 82% all the way up to 91%.
How we got there: Initially, I added dozens of tests using the standard AST Module -> Builder pipeline. This covered all the remaining float comparisons, VariableAssignment edge cases, timestamp errors, loop variations, etc. That got us up to ~85%.
However, we hit a hard ceiling because there are about ~200 lines in the builder (mostly vector math operations and string helper stubs) that are completely unreachable via the AST right now, since astx doesn't have vector types to parse and trigger those paths.
The new approach: To cross the 90% threshold, I changed the approach. I added a new test file (test_coverage_direct.py) that instantiates the LLVMLiteIRVisitor and tests its internal methods directly. I mocked the visitor's internal result_stack to feed LLVM vector constants and strings directly into the evaluation loops, effectively bypassing the AST entirely for these specific paths.This successfully let us test the LLVM IR generation for vector math, scalar-vector promotion, and the string functions. We now have 212 tests running cleanly and passing all checks!
Let me know if this direct-testing approach looks good to you!

[xmnlab]

hi @Jaskirat-s7 thanks for working on that.
would you mind opening a pr for that? so we can check your approach.
appreciate it.