Explore simple type flow analysis

[vinistock]

By analyzing the flow of types in a program, we may be able to improve the accuracy for definition, hover, completion and signature help.

For example, understanding the type stored in a variable

something = Foo.new
something #=> something is an instance of Foo here

However, the Ruby LSP doesn't require a type system to provide features. We may discover that investing in type flow analysis without a type system actually doesn't provide much benefit (because most things would end up being untyped anyway).

Explore implementing simple type flow analysis:

• Estimate the percentage of types we could understand better without a type system. This is limited to types discoverable without annotations:
  • Literals
  • Object instantiations (Object.new) only when self.new or self.allocate are not overridden
• Investigate the phases to flow types in the analysis. Do we need to implement a CFG? Are there other options? Trade offs?

The output of this task is either the implemented flow analysis algorithm or an explanation of why it's not worth it without a type system.

[vinistock]

We have explored this and came to the conclusion that, without type annotations, the increase in accuracy for resolutions would be minimal.

At the same time, there's no such thing as "simple" flow analysis, as even the simplest snippets of Ruby code will require a considerable amount of infrastructure to properly type check and at least the basics of a type system to represent.

Therefore, we decided to not move forward with this effort at this time.