racc-rbs-inline 0.1.0

data/lib/racc_rbs_inline/cli.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "fileutils"
+require "open3"
+require "optparse"
+require "rbconfig"
+require "tempfile"
+require "tmpdir"
+require_relative "../racc_rbs_inline"
+
+module RaccRbsInline
+  class CLI
+    HELP = <<~TEXT
+      Usage: racc-rbs-inline COMMAND [OPTIONS]
+
+        annotate [--stdout | --check] [--grammar GRAMMAR] FILE...
+        generate GRAMMAR -o OUT [-- RACC_OPTIONS]
+        sig [--output DIR]                         (default: sig/racc)
+        --version
+        --help
+    TEXT
+
+    # @rbs @out: untyped
+    # @rbs @err: untyped
+
+    #: (Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
+    def self.run(argv, out: $stdout, err: $stderr)
+      new(out: out, err: err).run(argv)
+    end
+
+    #: (out: untyped, err: untyped) -> void
+    def initialize(out:, err:)
+      @out = out
+      @err = err
+    end
+
+    #: (Array[String] argv) -> Integer
+    def run(argv)
+      args = argv.dup
+      case args.shift
+      when "annotate" then annotate(args)
+      when "generate" then generate(args)
+      when "sig" then sig(args)
+      when "--version", "-v"
+        raise Error, "unexpected arguments" unless args.empty?
+        @out.puts(VERSION)
+        0
+      when "--help", "-h"
+        @out.puts(HELP)
+        0
+      else
+        raise Error, HELP
+      end
+    rescue Error, OptionParser::ParseError, SystemCallError, IOError => error
+      @err.puts("racc-rbs-inline: #{error.message}")
+      1
+    end
+
+    private
+
+    #: (Array[String] args) -> Integer
+    def annotate(args)
+      stdout = false
+      check = false
+      grammar_path = nil #: String?
+      parser = OptionParser.new do |options|
+        options.banner = "Usage: racc-rbs-inline annotate [--stdout | --check] [--grammar GRAMMAR] FILE..."
+        options.on("--stdout", "Write annotated source to standard output") { stdout = true }
+        options.on("--check", "List files needing annotation without writing") { check = true }
+        options.on("--grammar FILE", "Use semantic types declared in a Racc grammar") { |path| grammar_path = path }
+        options.on("-h", "--help") { @out.puts(options); return 0 }
+      end
+      parser.parse!(args)
+      raise Error, "annotate requires at least one file" if args.empty?
+      raise Error, "--stdout and --check cannot be combined" if stdout && check
+      grammar_filename = grammar_path
+      grammar = grammar_filename ? File.read(grammar_filename) : nil
+
+      # Validate every input before replacing any of them.
+      results = args.map do |path|
+        source = File.binread(path)
+        [path, source, RaccRbsInline.annotate(source, grammar: grammar, grammar_filename: grammar_filename || "grammar.y")]
+      rescue Error => error
+        raise Error, "#{path}: #{error.message}"
+      end #: Array[[String, String, String]]
+      changed = false
+      results.each do |path, source, annotated|
+        if stdout
+          @out.write(annotated)
+        elsif source != annotated
+          changed = true
+          if check
+            @out.puts(path)
+          else
+            replace(path, annotated, File.stat(path).mode)
+          end
+        end
+      end
+      check && changed ? 1 : 0
+    end
+
+    #: (Array[String] args) -> Integer
+    def generate(args)
+      separator = args.index("--")
+      racc_options = [] #: Array[String]
+      if separator
+        racc_options = args.drop(separator + 1)
+        args = args.take(separator)
+      end
+      output_option = nil #: String?
+      parser = OptionParser.new do |options|
+        options.banner = "Usage: racc-rbs-inline generate GRAMMAR -o OUT [-- RACC_OPTIONS]"
+        options.on("-o", "--output FILE") { |path| output_option = path }
+        options.on("-h", "--help") { @out.puts(options); return 0 }
+      end
+      parser.parse!(args)
+      output = output_option || raise(Error, "generate requires -o OUT")
+      raise Error, "generate requires one grammar" unless args.length == 1
+      grammar = args.fetch(0)
+      if same_file?(grammar, output)
+        raise Error, "grammar and output must be different files"
+      end
+      raise Error, "pass the output path with -o before --" if racc_options.any? { |option| option == "--" || option.match?(/\A(?:-o|--output-file(?:=|\z))/) }
+      default_log = validate_log_paths(racc_options, grammar, output)
+
+      Dir.mktmpdir("racc-rbs-inline-", File.expand_path(File.dirname(output))) do |directory|
+        generated = File.join(directory, File.basename(output))
+        if File.exist?(output)
+          File.write(generated, "")
+          File.chmod(File.stat(output).mode & 0o777, generated)
+        end
+        # Racc derives verbose log names from the first dot in the output path.
+        racc_output = generated.delete_prefix("#{Dir.pwd}/")
+        validate_log_path(racc_output.sub(/(?:\..*?)?\z/, ".output"), grammar, output) if default_log
+        stdout, stderr, status = Open3.capture3(*racc_command, *racc_options, "-o", racc_output, grammar)
+        @out.write(stdout)
+        @err.write(stderr)
+        return status.exitstatus || 1 unless status.success?
+
+        require_relative "grammar_types"
+        grammar_source = File.read(grammar)
+        typed_grammar = GrammarTypes.declared?(grammar_source, filename: grammar) ? grammar_source : nil
+        annotated = RaccRbsInline.annotate(File.binread(generated), grammar: typed_grammar, grammar_filename: grammar)
+        # Racc's --verbose option also produces a .output file beside the parser.
+        artifacts = Dir.children(directory).reject { |name| name == File.basename(generated) }
+        artifacts.each do |name|
+          validate_log_path(File.join(File.dirname(output), name), grammar, output)
+        end
+        replace(output, annotated, File.stat(generated).mode)
+        artifacts.each do |name|
+          File.rename(File.join(directory, name), File.join(File.dirname(output), name))
+        end
+      end
+      0
+    end
+
+    #: (Array[String] options, String grammar, String output) -> bool
+    def validate_log_paths(options, grammar, output)
+      remaining = options.dup
+      verbose = false
+      explicit_log = false
+      parser = OptionParser.new do |flags|
+        flags.on("-O", "--log-file FILE") do |path|
+          validate_log_path(path, grammar, output)
+          explicit_log = true
+        end
+        flags.on("-v", "--verbose") { verbose = true }
+        # Recognize argument boundaries and short clusters; Racc validates all other options.
+        flags.on("-e", "--executable [PATH]") {}
+        flags.on("-o", "--output-file FILE") {}
+        flags.on("-D FLAGS") {}
+        flags.on("--superclass CLASS") {}
+        %w[-t -g -E -F -l -a -C -S -P --help --version].each { |flag| flags.on(flag) {} }
+      end
+      until remaining.empty?
+        begin
+          parser.order!(remaining) {}
+        rescue OptionParser::InvalidOption
+          next
+        end
+      end
+      verbose && !explicit_log
+    end
+
+    #: (String path, String grammar, String output) -> void
+    def validate_log_path(path, grammar, output)
+      if same_file?(path, grammar) || same_file?(path, output)
+        raise Error, "Racc log file must differ from grammar and output: #{path}"
+      end
+    end
+
+    #: (String first, String second) -> bool
+    def same_file?(first, second)
+      File.realdirpath(first) == File.realdirpath(second) || File.identical?(first, second)
+    end
+
+    #: () -> Array[String]
+    def racc_command
+      [RbConfig.ruby, Gem.bin_path("racc", "racc")]
+    rescue Gem::LoadError, RuntimeError
+      ["racc"]
+    end
+
+    #: (Array[String] args) -> Integer
+    def sig(args)
+      output = "sig/racc"
+      parser = OptionParser.new do |options|
+        options.banner = "Usage: racc-rbs-inline sig [--output DIR]"
+        options.on("-o", "--output DIR") { |path| output = path }
+        options.on("-h", "--help") { @out.puts(options); return 0 }
+      end
+      parser.parse!(args)
+      raise Error, "sig does not take positional arguments" unless args.empty?
+      source = File.binread(File.expand_path("../../data/racc/parser.rbs", File.dirname(__FILE__)))
+      FileUtils.mkdir_p(output)
+      path = File.join(output, "parser.rbs")
+      mode = File.exist?(path) ? File.stat(path).mode : 0o666 & ~File.umask
+      replace(path, source, mode)
+      0
+    end
+
+    #: (String path, String source, Integer mode) -> void
+    def replace(path, source, mode)
+      path = File.realpath(path) if File.symlink?(path)
+      Tempfile.create([".racc-rbs-inline-", ".tmp"], File.dirname(path)) do |file|
+        file.binmode
+        file.write(source)
+        file.flush
+        File.chmod(mode & 0o777, file.path)
+        File.rename(file.path, path)
+      end
+    end
+  end
+end

data/lib/racc_rbs_inline/grammar_types.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "prism"
+require "rbs"
+require "strscan"
+require "racc/grammarfileparser"
+
+module RaccRbsInline
+  class GrammarTypes
+    # @rbs @rules: Array[untyped]
+    # @rbs @table: untyped
+    # @rbs @result_var: bool
+    # @rbs @types: Hash[Symbol | String, String]
+
+    #: (String source, ?filename: String) -> bool
+    def self.declared?(source, filename: "grammar.y")
+      !grammar_comment_lines(source, filename).empty?
+    rescue Racc::CompileError, ArgumentError => error
+      raise Error, "#{filename}: #{error.message}"
+    end
+
+    #: (String source, ?filename: String) -> void
+    def initialize(source, filename: "grammar.y")
+      raise Error, "Grammar is empty" if source.strip.empty?
+
+      comment_lines = self.class.grammar_comment_lines(source, filename) { |text| literal_string(text) }
+      result = Racc::GrammarFileParser.parse(source, filename)
+      states = Racc::States.new(result.grammar).nfa
+      states.dfa
+      @table = states.state_transition_table
+      @rules = []
+      result.grammar.each { |rule| @rules << rule }
+      @result_var = result.params.result_var?
+      @types = declarations(source, comment_lines)
+      known = result.grammar.symboltable.symbols.reject(&:dummy?).map(&:value)
+      unknown = @types.keys - known
+      raise Error, "Unknown grammar symbols: #{unknown.map(&:inspect).join(', ')}" unless unknown.empty?
+    rescue Racc::CompileError, RBS::ParsingError, ArgumentError => error
+      raise Error, "#{filename}: #{error.message}"
+    end
+
+    #: (body: Prism::StatementsNode) -> Hash[Symbol, String]
+    def signatures(body:)
+      validate_tables(body)
+      signatures = {} #: Hash[Symbol, String]
+      return signatures if @types.empty?
+
+      body.body.each do |node|
+        next unless node.is_a?(Prism::DefNode)
+        match = node.name.to_s.match(/\A_reduce_(\d+)\z/)
+        next unless match
+
+        rule = @rules[match[1].to_i]
+        raise Error, "Reduction #{node.name} does not exist in the grammar" unless rule
+        next if rule.target.dummy?
+
+        expected = @result_var ? 3 : 2
+        raise Error, "Reduction #{node.name} parameters do not match the grammar" unless node.parameters&.requireds&.length == expected
+
+        types = rule.symbols.map { |symbol| type_for(symbol) } #: Array[String]
+        target = type_for(rule.target)
+        parameters = "[#{types.join(', ')}] val, Array[untyped] _values"
+        if @result_var
+          first = types.first || "nil"
+          parameters += ", #{union(first, target)} result"
+        end
+        signatures[node.name] = "#: (#{parameters}) -> #{target}"
+      end
+      signatures
+    end
+
+    private
+
+    #: (String source, String filename) ?{ (String) -> String } -> Array[Integer]
+    def self.grammar_comment_lines(source, filename, &decode)
+      scanner = Racc::GrammarFileScanner.new(source, filename)
+      raise Error, "Grammar has no rules" unless scanner.instance_variable_get(:@line)
+      # Never let Racc evaluate tokens while locating declaration comments.
+      scanner.define_singleton_method(:eval) { |text| decode ? decode.call(text) : text }
+      lines = [] #: Array[Integer]
+      record = lambda do
+        line = scanner.instance_variable_get(:@line) #: String?
+        if scanner.instance_variable_get(:@in_block).nil? && line&.match?(/\A\s*#\s*@racc-type\b/)
+          lines << scanner.lineno
+        end
+      end
+      advance = scanner.method(:next_line)
+      scanner.define_singleton_method(:next_line) do
+        available = advance.call
+        record.call if available
+        available
+      end
+      record.call
+      scanner.yylex { |_token| }
+      lines
+    end
+
+    #: (String source, Array[Integer] comment_lines) -> Hash[Symbol | String, String]
+    def declarations(source, comment_lines)
+      types = {} #: Hash[Symbol | String, String]
+      lines = source.lines
+      comment_lines.each do |number|
+        line = lines.fetch(number - 1)
+        match = line.match(/\A\s*#\s*@racc-type\b(.*)/)
+        next unless match
+
+        scanner = StringScanner.new(match[1])
+        symbols = [] #: Array[Symbol | String]
+        loop do
+          scanner.skip(/\s*/)
+          break if scanner.scan(/:/)
+          token = scanner.scan(/[A-Za-z_]\w*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/)
+          raise Error, "Invalid @racc-type declaration on line #{number}" unless token
+          symbols << (token.start_with?("'", '"') ? literal_string(token).b : token.to_sym)
+          unless scanner.eos? || scanner.peek(1).match?(/[\s:]/)
+            raise Error, "Invalid @racc-type symbols on line #{number}"
+          end
+        end
+        raise Error, "Missing symbols in @racc-type on line #{number}" if symbols.empty?
+
+        type = parse_type(scanner.rest.strip).to_s
+        symbols.each do |symbol|
+          if types.key?(symbol) && types[symbol] != type
+            raise Error, "Conflicting types for #{symbol.inspect} on line #{number}"
+          end
+          types[symbol] = type
+        end
+      end
+      types
+    end
+
+    #: (String source) -> String
+    def literal_string(source)
+      parsed = Prism.parse(source)
+      nodes = parsed.value.statements.body
+      node = nodes.first
+      unless parsed.success? && nodes.length == 1 && node.is_a?(Prism::StringNode)
+        raise Error, "Grammar symbols must be literal strings without interpolation"
+      end
+      node.unescaped
+    end
+
+    #: (untyped symbol) -> String
+    def type_for(symbol)
+      return @types.fetch(symbol.value, "untyped") unless symbol.dummy?
+
+      case symbol.value.to_s
+      when /\A-option@/
+        rule = @rules.find { |candidate| candidate.target == symbol && !candidate.symbols.empty? }
+        inner = parse_type(type_for(rule.symbols.first))
+        RBS::Types::Optional.new(type: inner, location: nil).to_s
+      when /\A-many1?@/
+        rule = @rules.find { |candidate| candidate.target == symbol && !candidate.symbols.empty? }
+        "Array[#{type_for(rule.symbols.first)}]"
+      when /\A-group@/
+        "Array[untyped]"
+      else
+        "untyped"
+      end
+    end
+
+    #: (String first, String target) -> String
+    def union(first, target)
+      return target if first == target
+
+      types = [first, target].map { |type| parse_type(type) }
+      RBS::Types::Union.new(types: types, location: nil).to_s
+    end
+
+    #: (String source) -> RBS::Types::t
+    def parse_type(source)
+      RBS::Parser.parse_type(source, require_eof: true, void_allowed: false) || raise(Error, "Missing RBS type in @racc-type declaration")
+    end
+
+    #: (Prism::StatementsNode body) -> void
+    def validate_tables(body)
+      expected = {
+        racc_action_table: @table.action_table,
+        racc_action_check: @table.action_check,
+        racc_action_default: @table.action_default,
+        racc_action_pointer: @table.action_pointer,
+        racc_goto_table: @table.goto_table,
+        racc_goto_check: @table.goto_check,
+        racc_goto_default: @table.goto_default,
+        racc_goto_pointer: @table.goto_pointer,
+        racc_reduce_table: @table.reduce_table,
+        racc_reduce_n: @rules.length,
+        racc_nt_base: @table.nt_base,
+        racc_use_result_var: @result_var,
+        Racc_token_to_s_table: @table.token_to_s_table
+      } #: Hash[Symbol, untyped]
+      expected.each do |name, value|
+        nodes = body.body.select do |node|
+          (node.is_a?(Prism::LocalVariableWriteNode) || node.is_a?(Prism::ConstantWriteNode)) && node.name == name
+        end
+        node = nodes.first
+        unless nodes.length == 1 && (node.is_a?(Prism::LocalVariableWriteNode) || node.is_a?(Prism::ConstantWriteNode)) && literal(node.value) == value
+          raise Error, "Generated #{name} does not match the grammar; regenerate with the same Racc version"
+        end
+      end
+    end
+
+    #: (Prism::Node node) -> untyped
+    def literal(node)
+      case node
+      when Prism::ArrayNode then node.elements.map { |element| literal(element) }
+      when Prism::IntegerNode then node.value
+      when Prism::SymbolNode then node.unescaped.to_sym
+      when Prism::StringNode then node.unescaped
+      when Prism::TrueNode then true
+      when Prism::FalseNode then false
+      when Prism::NilNode then nil
+      else
+        raise Error, "Generated grammar tables must contain only literals"
+      end
+    end
+  end
+end

data/lib/racc_rbs_inline/rake_task.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "rake"
+require_relative "cli"
+
+module RaccRbsInline
+  class RakeTask
+    include Rake::DSL
+
+    attr_accessor :grammar #: String?
+    attr_accessor :output #: String?
+    attr_accessor :options #: Array[String]
+
+    #: (?Symbol | String name) ?{ (RakeTask) -> void } -> void
+    def initialize(name = :parser)
+      @grammar = nil
+      @output = nil
+      @options = []
+      yield self if block_given?
+      grammar = @grammar
+      output = @output
+      raise ArgumentError, "grammar and output are required" unless grammar && output
+
+      desc "Generate #{output} with RBS inline annotations"
+      task name => output
+      file output => grammar do
+        FileUtils.mkdir_p(File.dirname(output))
+        status = CLI.run(["generate", grammar, "-o", output, "--", *@options])
+        raise Error, "parser generation failed (exit #{status})" unless status.zero?
+      end
+    end
+  end
+end

data/lib/racc_rbs_inline/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module RaccRbsInline
+  VERSION = "0.1.0"
+end

data/lib/racc_rbs_inline.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "racc_rbs_inline/version"
+
+module RaccRbsInline
+  class Error < StandardError; end
+
+  #: (String source, ?grammar: String?, ?grammar_filename: String) -> String
+  def self.annotate(source, grammar: nil, grammar_filename: "grammar.y")
+    Annotator.new.annotate(source, grammar: grammar, grammar_filename: grammar_filename)
+  end
+
+  #: (String source) -> bool
+  def self.annotated?(source)
+    Annotator.new.annotated?(source)
+  end
+end
+
+require_relative "racc_rbs_inline/annotator"

data/sig/generated/racc_rbs_inline/annotator.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/racc_rbs_inline/annotator.rb with RBS::Inline
+
+module RaccRbsInline
+  class Annotator
+    MAGIC: String
+
+    INTEGER_TABLE: Regexp
+
+    REDUCTION: Regexp
+
+    CONSTANT_TYPES: Hash[Symbol, String]
+
+    # : (String source, ?grammar: String?, ?grammar_filename: String) -> String
+    def annotate: (String source, ?grammar: String?, ?grammar_filename: String) -> String
+
+    # : (String source) -> bool
+    def annotated?: (String source) -> bool
+
+    private
+
+    # : (String source) -> String
+    def unwrap: (String source) -> String
+
+    # : (String source, types: GrammarTypes?, existing: bool) -> String
+    def add_annotations: (String source, types: GrammarTypes?, existing: bool) -> String
+
+    # : (Prism::LocalVariableWriteNode node) -> String?
+    def table_type: (Prism::LocalVariableWriteNode node) -> String?
+
+    # : (Prism::Node node, String type) -> [Integer, Integer, String]
+    def trailing: (Prism::Node node, String type) -> [ Integer, Integer, String ]
+
+    # : (String source) -> String
+    def add_magic_comment: (String source) -> String
+
+    # : (String source) -> String
+    def newline: (String source) -> String
+
+    # : (String source) -> Prism::ProgramNode
+    def parse!: (String source) -> Prism::ProgramNode
+
+    # : (Prism::ProgramNode program) -> Array[Prism::StatementsNode]
+    def parser_bodies: (Prism::ProgramNode program) -> Array[Prism::StatementsNode]
+
+    # : (String binary, Integer offset) -> Integer
+    def line_start: (String binary, Integer offset) -> Integer
+
+    # : (String source, Array[[Integer, Integer, String]] edits) -> String
+    def apply: (String source, Array[[ Integer, Integer, String ]] edits) -> String
+  end
+end

data/sig/generated/racc_rbs_inline/cli.rbs

@@ -0,0 +1,46 @@
+# Generated from lib/racc_rbs_inline/cli.rb with RBS::Inline
+
+module RaccRbsInline
+  class CLI
+    HELP: ::String
+
+    @out: untyped
+
+    @err: untyped
+
+    # : (Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
+    def self.run: (Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
+
+    # : (out: untyped, err: untyped) -> void
+    def initialize: (out: untyped, err: untyped) -> void
+
+    # : (Array[String] argv) -> Integer
+    def run: (Array[String] argv) -> Integer
+
+    private
+
+    # : (Array[String] args) -> Integer
+    def annotate: (Array[String] args) -> Integer
+
+    # : (Array[String] args) -> Integer
+    def generate: (Array[String] args) -> Integer
+
+    # : (Array[String] options, String grammar, String output) -> bool
+    def validate_log_paths: (Array[String] options, String grammar, String output) -> bool
+
+    # : (String path, String grammar, String output) -> void
+    def validate_log_path: (String path, String grammar, String output) -> void
+
+    # : (String first, String second) -> bool
+    def same_file?: (String first, String second) -> bool
+
+    # : () -> Array[String]
+    def racc_command: () -> Array[String]
+
+    # : (Array[String] args) -> Integer
+    def sig: (Array[String] args) -> Integer
+
+    # : (String path, String source, Integer mode) -> void
+    def replace: (String path, String source, Integer mode) -> void
+  end
+end

data/sig/generated/racc_rbs_inline/grammar_types.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/racc_rbs_inline/grammar_types.rb with RBS::Inline
+
+module RaccRbsInline
+  class GrammarTypes
+    @rules: Array[untyped]
+
+    @table: untyped
+
+    @result_var: bool
+
+    @types: Hash[Symbol | String, String]
+
+    # : (String source, ?filename: String) -> bool
+    def self.declared?: (String source, ?filename: String) -> bool
+
+    # : (String source, ?filename: String) -> void
+    def initialize: (String source, ?filename: String) -> void
+
+    # : (body: Prism::StatementsNode) -> Hash[Symbol, String]
+    def signatures: (body: Prism::StatementsNode) -> Hash[Symbol, String]
+
+    private
+
+    # : (String source, String filename) ?{ (String) -> String } -> Array[Integer]
+    def self.grammar_comment_lines: (String source, String filename) ?{ (String) -> String } -> Array[Integer]
+
+    # : (String source, Array[Integer] comment_lines) -> Hash[Symbol | String, String]
+    def declarations: (String source, Array[Integer] comment_lines) -> Hash[Symbol | String, String]
+
+    # : (String source) -> String
+    def literal_string: (String source) -> String
+
+    # : (untyped symbol) -> String
+    def type_for: (untyped symbol) -> String
+
+    # : (String first, String target) -> String
+    def union: (String first, String target) -> String
+
+    # : (String source) -> RBS::Types::t
+    def parse_type: (String source) -> RBS::Types::t
+
+    # : (Prism::StatementsNode body) -> void
+    def validate_tables: (Prism::StatementsNode body) -> void
+
+    # : (Prism::Node node) -> untyped
+    def literal: (Prism::Node node) -> untyped
+  end
+end

data/sig/generated/racc_rbs_inline/rake_task.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/racc_rbs_inline/rake_task.rb with RBS::Inline
+
+module RaccRbsInline
+  class RakeTask
+    include Rake::DSL
+
+    attr_accessor grammar: String?
+
+    attr_accessor output: String?
+
+    attr_accessor options: Array[String]
+
+    # : (?Symbol | String name) ?{ (RakeTask) -> void } -> void
+    def initialize: (?Symbol | String name) ?{ (RakeTask) -> void } -> void
+  end
+end

data/sig/generated/racc_rbs_inline/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/racc_rbs_inline/version.rb with RBS::Inline
+
+module RaccRbsInline
+  VERSION: ::String
+end