RBS: Error using tapioca gem on herb because of malformed RBS on lex_file and parse_file

[domingo2000]

When using bundle exec tapioca dsl in our project with the latest tapioca version, the .rbi autogenerated for Herb is invalid. This happens because there is an invalid RBS signature for the API of lex_file and parse_file that are not declaring the ** argument.

I will open a PR fixing the comment, but leave the issue for now to track it.

[marcoroth]

Thanks for reporting @domingo2000!

I wonder if this is worth a bug in Tapioca too, as I don't really see why the inline RBS signature would technically be invalid.

[domingo2000]

From this rbs docs I understand that splats in RBS should be typed.

Maybe Tapioca could be more forgiving in not typing splats correctly and generate a correct syntax.

But the complete signature typing the splats seems to correct the issue in the tapioca rbs->sorbet translation.

[marcoroth]

At least in the case of #1990, all the kwargs that ** could enumerate are already explicitly declared in the signature, so adding **untyped makes it look like there are more options that aren't listed, which isn't the case.

I wonder if we need to repeat all kwargs again in the actual method declaration, which would be a bit cumbersome.

[domingo2000]

Tried using

def parse_file: (String path, ...) -> ParseResult
def lex_file:   (String path, ...) -> LexResult

As RBS for this case, but it makes the results untyped that is a worse output.

[domingo2000]

I could do something like this adding all the signatures:

   # Sentinel so parse_file can distinguish omitted max_errors from max_errors: nil (unlimited).
    MAX_ERRORS_UNSET = Object.new.freeze
    private_constant :MAX_ERRORS_UNSET

    #: (String path, ?arena_stats: bool) -> LexResult
    def lex_file(path, arena_stats: nil)
      options = { arena_stats: }.compact
      lex(File.read(path), **options)
    end

    #: (String path, ?track_whitespace: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?timeout: Numeric, ?max_errors: Integer?, ?arena_stats: bool) -> ParseResult
    def parse_file(
      path,
      track_whitespace: nil,
      analyze: nil,
      strict: nil,
      action_view_helpers: nil,
      transform_conditionals: nil,
      dot_notation_tags: nil,
      render_nodes: nil,
      strict_locals: nil,
      iteration_nodes: nil,
      prism_nodes: nil,
      prism_nodes_deep: nil,
      prism_program: nil,
      html: nil,
      timeout: nil,
      max_errors: MAX_ERRORS_UNSET,
      arena_stats: nil
    )
      options = {
        track_whitespace:,
        analyze:,
        strict:,
        action_view_helpers:,
        transform_conditionals:,
        dot_notation_tags:,
        render_nodes:,
        strict_locals:,
        iteration_nodes:,
        prism_nodes:,
        prism_nodes_deep:,
        prism_program:,
        html:,
        timeout:,
        arena_stats:,
      }.compact

      # max_errors: nil is meaningful (unlimited); only forward when the caller passed it.
      options[:max_errors] = max_errors unless MAX_ERRORS_UNSET.equal?(max_errors)

      parse(File.read(path), **options)

There are some params not declared in the current sig that the C extension receives, and also some quirks from the max errors api that changes behaviour if the param is passed as nil, not passed or passed an integer. (This mapping of types was AI generated by inspecting the RBS of the options and the C extension intself).

So if it is ok i will add it to the PR, if not, feel free to take the PR and resolve the signature tapioca problem as you like.