Add rewriter to transform attributes into methods

[amomchilov]

Part of Shopify/tapioca#1918

This PR introduces a new rewriter which transforms attr_reader/attr_writer/attr_accessor RBIs into methods with the corresponding sigs. This has two benefits:

1. It naturally solves Merging attributes with annotations fails tapioca#1709. If Tapioca only has to deal with methods (which can already be merged), then we don't have to write bespoke logic to merge attributes with methods, or methods with attributes.
2. It'll leave less work for Sorbet, which internally rewrites attributes into methods. We can do this on its behalf, once up-front, rather than on every parse of the RBIs.

[Morriar]

Sig overloads are allowed in RBI files: sorbet/sorbet#7412

[amomchilov]

Not for attributes, though. Sorbet.run

[Morriar]

In .rbi files only. With sorbet.run you're testing with a .rb file.

[amomchilov]

Indeed, looks like it allows it, but the revealed type is whichever one you listed first. I think we should warn in that case, it likely wasn't intended.

[Morriar]

We currently do not do any linting / warning inside rbi, it's up to the client to make sure that what is produced is correct.

This could be a warning in Tapioca when pulling the gem's hand-written annotations. Or it could be done by Sorbet.

[amomchilov]

Here were the previously open questions. Spoke offline, decisions in-line.

1. Which attr_writer sig should we accept?

Decision: Be flexible, and accept both .void and .returns(Type). Reevaluate if Sorbet changes its behaviour to prefer one or the other

Sorbet accepts both of these (should it?):

sig { params(a: Integer).void }
attr_writer :a

sig { params(b: Integer).returns(Integer) }
attr_writer :b

Sorbet.run

According to Sorbet, the result of these expressions is always just whatever is assigned to them, ignoring the return type of the sig (so perhaps we should only accept void?):

result_of_a = (self.a = 123)
T.reveal_type(result_of_a) # => Integer

result_of_b = (self.b = 123)
T.reveal_type(result_of_b) # => Integer

But the writer methods themselves do actually return the value:

class C
  attr_writer :foo
end

C.new.send(:foo=, 123) # => 123

So both seem reasonable. Should we permissively accept either one?

2. Which sig should we generate for writers?

Decision: Always emit .void.

It's not obvious which of these would be better. Consider "normal" Ruby code (not RBIs), which needs to implement a setter method:

class C
  def s=(_)
    "This return value isn't normally used"
  end
end

object = C.new

result_of_setter = (object.s = "This value is always returned")
result_of_setter # => "This value is always returned"

# ... makes sense, except:

result_of_send = object.send(:s=, "Now this isn't returned")
result_of_send # => "This return value isn't normally used"

• From the caller perspective .returns(String) is correct
• But from an implementer's side, .void is correct (you're not obligated to return a string)

[amomchilov]

6 params, but the upper limit is 5. Worth overriding?

[amomchilov]

Curious, why does this work correctly without needing a .dup?

Suggested change

	visit_all(node.nodes)
	visit_all(node.nodes.dup)

There seems to be a risk of concurrently modifying an array while it's being iterated by the visitor. Perhaps we just don't hit that edge case in our tests.

[Morriar]

I think you need a test iterating over multiple nodes:

class Foo
  def foo; end
  attr_accessor :bar
  def baz; end
end

[amomchilov]

Yeah I tried that, and a bunch of more complex cases, and they all work fine lol

[amomchilov]

Ah, it's needed, so I added.

This case reproduces it:

      rbi = Parser.parse_string(<<~RBI)
        class Foo
          sig { returns(Integer) }
          attr_reader :i1

          sig { returns(Integer) }
          attr_reader :i2
        end
      RBI

I thought I by alternating def and attr I'd have the highest chance of hitting it, but in fact, that's the only safe configuration haha

[Morriar]

I think you need a test iterating over multiple nodes:

class Foo
  def foo; end
  attr_accessor :bar
  def baz; end
end

[Morriar]

Suggested change

[Morriar]

Suggested change

	attr_reader :node
	sig { returns(Node) }
	attr_reader :node