Re-evaluate typed arguments without types

[maedi]

When config.type_checking is disabled we currently prepend a "shim" method that ignores validating the types in the user's code. So when calling a previously typed method there is always a guard method to go through. This impacts performance by adding additional method calls in the prepended "shim" method. Instead let's rewrite the method to contain no types at all.

Benefits:

• Improve performance (no "shim" method)
• Simplify debugging (one less step)
• Shorten stack traces (one less line)

Implementation

Rewrite the method's params to be "untyped". This involves redefining the method using class_eval, or eval if that's the only way we can mirror the line numbers of the original method. LowType will use Lowkey in the "redefiner" phase to alter each ParamProxy in a MethodProxy to be untyped, and to delete its ReturnProxy if it exists. Then you do "method_proxy.export" to export the modified code, and eval() that code or similar to overwrite existing typed methods. Lowkey is very good at understanding the start_line/end_line and has an array of "lines" just for your particular proxy. So you can easily target the right spot in the source code, but I've only just finished this feature and it needs more work.

[obsidiannnn]

Dug into the current Lowkey export API to understand what needs work before the rewrite can rely on it. Here is what I found:
What works today:-

method_proxy.export returns the raw source lines joined : read-only dump of the original typed source, no transformation
method_proxy.lines returns the mutable array of source lines between start_line and end_line.

What is missing:-

ParamProxy has no API to strip its type annotation from the source line , value and type are readable but there is no "make this param untyped" method that updates the underlying source.
return_proxy is attr_reader only, no setter or remove_return_proxy method, so LowType cannot nil it out before export
Source #export just dumps raw lines , there is no "export after modifications" flow that accounts for param rewrites.

What needs fixing in Lowkey:-

ParamProxy needs a method to rewrite its type annotation out of the source line.
MethodProxy#return_proxy needs to be attr_accessor or have a remove_return_proxy method.
Source#export needs to reflect modifications made to params before dumping.

These map exactly to what you mentioned , the bones are there but the export API needs polish. Happy to contribute these fixes to Lowkey as part of the foundational work.

[maedi]

method_proxy.lines returns the mutable array of source lines between start_line and end_line.

This may not be true. Needs investigation. Gotta add the start and end indexes yourself I believe, as lines is for the entire file. It kind of has to be this way though, as pre filtering the lines would create a new array, so you wouldn't be mutating the original anymore

[obsidiannnn]

You're right : lines is the entire file array shared across all proxies, not pre-filtered to the method's range. start_line and end_line are the indexes into it. So to target the method's lines you'd slice with lines[start_line - 1..end_line - 1], and since it's the same shared array, mutations there are reflected when export is called. Pre-filtering would have broken mutation, makes sense now why it works this way.

[maedi]

Instead of lines[start_line - 1..end_line - 1] you can do lines[start_index..end_index], but this would still be creating a copy. You would instead replace each line one at a time with lines[0] = 'test' or use lines=(new_lines) (https://github.com/low-rb/lowkey/blob/main/lib/models/source.rb#L19C9-L19C26), or build a new method in lowkey that does what you want.

[obsidiannnn]

Got it ...slicing still creates a copy so mutations don't reflect back. The right approach is either replacing line by line with lines[index] = 'new line' to mutate in place, or using the lines= setter on Source to replace the whole array. I'll look at the lines= setter and figure out which fits better for the param rewrite use case.