Question about the intended semantics for inline `#:` type assertions on local variables

[infiton]

Now that inline RBS comments are in ruby/rbs I'd like to clarify what the #: type assertion on a local variable is supposed to mean and to make sure that we aren't baking in a semantic difference between steep and sorbet.

For instance in the following code:

x = "hi" #: String
x = 5

• Steep (verified on 2.0.0) treats #: as a type assertion on the expression (introduced in Steep 1.3 as "declaring the type of an expression inline, without introducing a new local variable with a @type var annotation"). The local remains flow-typed, so the later x = 5 re-infers x to Integer — no error at the reassignment.
• Sorbet (verified on 0.6.13327 (RBS comments support) lowers x = v #: T to x = T.let(v, T). T.let declares the local's type for the whole method scope, so x = 5 is an error ("Incompatible assignment to variable declared via let").

This is extra confusing because in the case of

class Foo
  attr_accessor :bar #: String?
end

foo = Foo.new
Foo.bar = 5

results in an error in both Steep and Sorbet.

Questions

1. Is the semantics of a #: assertion on a local variable intended to be an expression-level assertion (Steep's behavior), a scope-level declaration/pin (Sorbet's T.let behavior), or is it deliberately left to each checker?
2. If it's left to checkers by design, can we consider documenting that (e.g. in docs/) so tool authors and users know portability is not guaranteed here?
3. If a single intended meaning is desired, is there a preference — and would it be worth a note in the inline-syntax docs so Steep/Sorbet/other implementations (RubyMine, and third-party checkers) can converge?

[soutaro]

Hi @infiton, I'm sorry for the confusion. It's complicated as you said.

1. RBS provides type annotation for global level constructs, methods, attributes, and constants. Steep handles type assertion on local expressions.
2. Sorbet implements its own semantics. While it tries to keep some compatibility with RBS syntax, they are essentially different things, at least for now.

[infiton]

@soutaro thank you for your response! What I'm looking for on this issue is an understanding of what the intended semantic is? Should Steep's semantics be seen as the reference implementation of rbs? Or is it really that we want to leave the interpretation of inline type assertions like this up to the checker?

[juharris]

I don't think attr_accessor :bar #: String? does anything. Isn't that just a comment at the end of a line? I believe accessors should have the comment before.

I normally do:

  #: String?
  attr_accessor :bar

[infiton]

yah sorry that was just a typo as I was writing it up; I meant to write (and this is what led to the type error on both sorbet and steep

  #: String?
  attr_accessor :bar