rbs_protobuf 0.1.0

data/example/b.proto

@@ -0,0 +1,10 @@
+syntax = "proto2";
+
+package rbs_protobuf.example;
+
+import 'a.proto';
+
+extend rbs_protobuf.example.Project {
+  optional string new_name = 100;
+}
+

data/example/protobuf_gem_example.rb

@@ -0,0 +1,32 @@
+require "protobuf"
+require_relative "protobuf-gem/a.pb.rb"
+require_relative "protobuf-gem/b.pb.rb"
+
+request = Rbs_protobuf::Example::SearchRequest.decode("")
+request.corpus = :VIDEO
+
+request.corpus = Rbs_protobuf::Example::SearchRequest::Corpus::WEB
+
+corpus = request.corpus
+
+query = request[:query]
+
+
+req = Rbs_protobuf::Example::SearchRequest.new(corpus: :VIDEO, query: "Hello world")
+
+
+response = Rbs_protobuf::Example::SearchResponse.new()
+
+response.result.each do |result|
+
+end
+
+response.result.clear
+response.result[0] = nil
+
+project = Rbs_protobuf::Example::Project.new
+project.projects["sub project 1"] = Rbs_protobuf::Example::Project.new
+
+project = Rbs_protobuf::Example::Project.new
+s = project.new_name
+project.new_name = "Hello world"

data/exe/protoc-gen-rbs

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(__dir__, "../lib")
+
+require "rbs_protobuf"
+
+backend = ENV["RBS_PROTOBUF_BACKEND"]
+unless backend
+  STDERR.puts "🚨🚨🚨 protoc-gen-rbs requires RBS_PROTOBUF_BACKEND environment variable. 🚨🚨🚨"
+  STDERR.puts "  Possible options:"
+  STDERR.puts "    RBS_PROTOBUF_BACKEND=protobuf         (for protobuf gem)"
+  STDERR.puts "    RBS_PROTOBUF_BACKEND=google-protobuf  (for google-protobuf gem)"
+  exit 1
+end
+
+input = Google::Protobuf::Compiler::CodeGeneratorRequest.decode(STDIN.read)
+
+translator = case backend
+             when "protobuf"
+               upcase_enum = ENV.key?("PB_UPCASE_ENUMS")
+               no_nested_namespace = ENV.key?("RBS_PROTOBUF_NO_NESTED_NAMESPACE")
+
+               RBSProtobuf::Translator::ProtobufGem.new(
+                 input,
+                 upcase_enum: upcase_enum,
+                 nested_namespace: !no_nested_namespace
+               )
+             when "google-protobuf"
+               raise NotImplementedError
+             end
+
+translator.generate_rbs!
+
+response = translator.response
+print Google::Protobuf::Compiler::CodeGeneratorResponse.encode(response)

data/lib/rbs_protobuf.rb

@@ -0,0 +1,19 @@
+require "rbs_protobuf/version"
+
+require "logger"
+
+require "protobuf/descriptors"
+require "active_support/inflector"
+require "rbs"
+
+module RBSProtobuf
+  class <<self
+    attr_reader :logger
+  end
+
+  @logger = Logger.new(STDERR)
+end
+
+require "rbs_protobuf/rbs_factory"
+require "rbs_protobuf/translator/base"
+require "rbs_protobuf/translator/protobuf_gem"

data/lib/rbs_protobuf/rbs_factory.rb

@@ -0,0 +1,149 @@
+module RBSProtobuf
+  class RBSFactory
+    include RBS
+
+    def type_name(string)
+      absolute = string.start_with?("::")
+
+      *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
+
+      TypeName.new(
+        name: name,
+        namespace: Namespace.new(path: path, absolute: absolute)
+      )
+    end
+
+    def namespace(string)
+      absolute = string.start_with?("::")
+      path = string.delete_prefix("::").split("::").map(&:to_sym)
+
+      Namespace.new(
+        path: path,
+        absolute: absolute
+      )
+    end
+
+    def instance_type(name, *args)
+      type_name = case name
+                  when TypeName
+                    name
+                  else
+                    type_name(name)
+                  end
+
+      Types::ClassInstance.new(name: type_name, args: args, location: nil)
+    end
+
+    def singleton_type(name)
+      type_name = case name
+                  when TypeName
+                    name
+                  else
+                    type_name(name)
+                  end
+
+      Types::ClassSingleton.new(name: type_name, location: nil)
+    end
+
+    def union_type(type, *types)
+      if types.empty?
+        type
+      else
+        Types::Union.new(
+          types: [type] + types,
+          location: nil
+        )
+      end
+    end
+
+    def nil_type(location: nil)
+      RBS::Types::Bases::Nil.new(location: location)
+    end
+
+    def bool_type(location: nil)
+      RBS::Types::Bases::Bool.new(location: location)
+    end
+
+    def alias_type(name, location: nil)
+      type_name = case name
+                  when TypeName
+                    name
+                  else
+                    type_name(name)
+                  end
+
+      Types::Alias.new(name: type_name, location: nil)
+    end
+
+    def function(return_type = Types::Bases::Void.new(location: nil))
+      Types::Function.empty(return_type)
+    end
+
+    def param(type, name: nil)
+      Types::Function::Param.new(
+        type: type,
+        name: name
+      )
+    end
+
+    def block(function, required: true)
+      MethodType::Block.new(
+        type: function,
+        required: required
+      )
+    end
+
+    def untyped(location: nil)
+      Types::Bases::Any.new(location: location)
+    end
+
+    def method_type(params: [], type:, block: nil, location: nil)
+      MethodType.new(
+        type_params: params,
+        type: type,
+        block: block,
+        location: location
+      )
+    end
+
+    def literal_type(literal)
+      Types::Literal.new(
+        literal: literal,
+        location: nil
+      )
+    end
+
+    def optional_type(type, location: nil)
+      Types::Optional.new(
+        type: type,
+        location: location
+      )
+    end
+
+    def type_var(name, location: nil)
+      Types::Variable.new(
+        name: name,
+        location: location
+      )
+    end
+
+    def module_type_params(*params)
+      params.each.with_object(AST::Declarations::ModuleTypeParams.empty) do |param, type_params|
+        type_params.add(AST::Declarations::ModuleTypeParams::TypeParam.new(
+          name: param,
+          variance: :invariant,
+          skip_validation: false
+        ))
+      end
+    end
+
+    def unwrap_optional(type)
+      case type
+      when RBS::Types::Optional
+        unwrap_optional(type.type)
+      else
+        type
+      end
+    end
+  end
+end

data/lib/rbs_protobuf/translator/base.rb

@@ -0,0 +1,100 @@
+module RBSProtobuf
+  module Translator
+    class Base
+      FieldDescriptorProto = Google::Protobuf::FieldDescriptorProto
+
+      attr_reader :input
+
+      def initialize(input)
+        @input = input
+      end
+
+      def factory
+        @factory ||= RBSFactory.new()
+      end
+
+      def response
+        @response ||= Google::Protobuf::Compiler::CodeGeneratorResponse.new
+      end
+
+      def generate_rbs!
+        input.proto_file.each do |file|
+          response.file << Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(
+            name: rbs_name(file.name),
+            content: rbs_content(file)
+          )
+        end
+      end
+
+      def rbs_name(proto_name)
+        dirname = File.dirname(proto_name)
+        basename = File.basename(proto_name, File.extname(proto_name))
+        rbs_name = "#{basename}#{rbs_suffix}.rbs"
+
+        File.join(dirname, rbs_name)
+      end
+
+      def rbs_suffix
+        ""
+      end
+
+      def rbs_content(file)
+        raise NotImplementedError
+      end
+
+      def comment_for_path(source_code_info, path)
+        loc = source_code_info.location.find {|loc| loc.path == path }
+        if loc
+          comments = []
+          if loc.leading_comments.length > 0
+            comments << loc.leading_comments.strip
+          end
+          if loc.trailing_comments.length > 0
+            comments << loc.trailing_comments.strip
+          end
+          if comments.empty? && !loc.leading_detached_comments.empty?
+            comments << loc.leading_detached_comments.join("\n\n").strip
+          end
+          RBS::AST::Comment.new(
+            location: nil,
+            string: comments.join("\n\n")
+          )
+        end
+      end
+
+      def base_type(type)
+        case type
+        when FieldDescriptorProto::Type::TYPE_STRING,
+          FieldDescriptorProto::Type::TYPE_BYTES
+          RBS::BuiltinNames::String.instance_type
+        when FieldDescriptorProto::Type::TYPE_INT32, FieldDescriptorProto::Type::TYPE_INT64,
+          FieldDescriptorProto::Type::TYPE_UINT32, FieldDescriptorProto::Type::TYPE_UINT64,
+          FieldDescriptorProto::Type::TYPE_FIXED32, FieldDescriptorProto::Type::TYPE_FIXED64,
+          FieldDescriptorProto::Type::TYPE_SINT32, FieldDescriptorProto::Type::TYPE_SINT64,
+          FieldDescriptorProto::Type::TYPE_SFIXED32, FieldDescriptorProto::Type::TYPE_SFIXED64
+          RBS::BuiltinNames::Integer.instance_type
+        when FieldDescriptorProto::Type::TYPE_DOUBLE, FieldDescriptorProto::Type::TYPE_FLOAT
+          RBS::BuiltinNames::Float.instance_type
+        when FieldDescriptorProto::Type::TYPE_BOOL
+          factory.union_type(factory.literal_type(true),
+                             factory.literal_type(false))
+        else
+          raise "Unknown base type: #{type}"
+        end
+      end
+
+      def message_type(string)
+        absolute = string.start_with?(".")
+
+        *path, name = string.delete_prefix(".").split(".").map {|s| ActiveSupport::Inflector.upcase_first(s).to_sym }
+
+        factory.instance_type(
+          RBS::TypeName.new(
+            name: name,
+            namespace: RBS::Namespace.new(path: path, absolute: absolute)
+          )
+        )
+      end
+    end
+  end
+end

data/lib/rbs_protobuf/translator/protobuf_gem.rb

@@ -0,0 +1,583 @@
+module RBSProtobuf
+  module Translator
+    class ProtobufGem < Base
+      def initialize(input, upcase_enum:, nested_namespace:)
+        super(input)
+        @upcase_enum = upcase_enum
+        @nested_namespace = nested_namespace
+      end
+
+      def upcase_enum?
+        @upcase_enum
+      end
+
+      def nested_namespace?
+        @nested_namespace
+      end
+
+      def rbs_content(file)
+        decls = []
+
+        source_code_info = file.source_code_info
+
+        if file.package && !file.package.empty?
+          package_namespace = message_type(file.package).name.to_namespace
+        else
+          package_namespace = RBS::Namespace.empty
+        end
+
+        prefix = if nested_namespace?
+                   RBS::Namespace.empty
+                 else
+                   package_namespace
+                 end
+
+        file.enum_type.each_with_index do |enum, index|
+          decls << enum_type_to_decl(enum,
+                                     prefix: prefix,
+                                     source_code_info: source_code_info,
+                                     path: [5, index])
+        end
+
+        file.message_type.each_with_index do |message, index|
+          decls << message_to_decl(message,
+                                   prefix: prefix,
+                                   message_path: if package_namespace.empty?
+                                                   [message.name.to_sym]
+                                                 else
+                                                   [file.package.to_sym, message.name.to_sym]
+                                                 end,
+                                   source_code_info: source_code_info,
+                                   path: [4, index])
+        end
+
+        file.service.each_with_index do |service, index|
+          decls << service_to_decl(service,
+                                   prefix: prefix,
+                                   source_code_info: source_code_info,
+                                   path: [6, index])
+        end
+
+        if nested_namespace?
+          package_namespace.path.reverse_each do |name|
+            decls = [
+              RBS::AST::Declarations::Module.new(
+                name: factory.type_name(name.to_s),
+                self_types: [],
+                type_params: factory.module_type_params,
+                location: nil,
+                comment: nil,
+                annotations: [],
+                members: decls
+              )
+            ]
+          end
+        end
+
+        file.extension.group_by(&:extendee).each.with_index do |(name, extensions), index|
+          decls.push(*extension_to_decl(name,
+                                        extensions,
+                                        prefix: RBS::Namespace.root,
+                                        source_code_info: source_code_info,
+                                        path: [7, index]))
+        end
+
+        StringIO.new.tap do |io|
+          RBS::Writer.new(out: io).write(decls)
+        end.string
+      end
+
+      def message_base_class
+        RBS::AST::Declarations::Class::Super.new(
+          name: RBS::TypeName.new(
+            name: :Message,
+            namespace: RBS::Namespace.parse("::Protobuf")
+          ),
+          args: [],
+          location: nil
+        )
+      end
+
+      def repeated_field_type(type, wtype = type)
+        factory.instance_type(
+          factory.type_name("::Protobuf::Field::FieldArray"),
+          type,
+          wtype
+        )
+      end
+
+      def message_to_decl(message, prefix:, message_path:, source_code_info:, path:)
+        class_name = ActiveSupport::Inflector.upcase_first(message.name)
+        decl_namespace = prefix.append(class_name.to_sym)
+
+        RBS::AST::Declarations::Class.new(
+          name: RBS::TypeName.new(name: class_name.to_sym, namespace: prefix),
+          super_class: message_base_class,
+          type_params: RBS::AST::Declarations::ModuleTypeParams.empty,
+          location: nil,
+          comment: comment_for_path(source_code_info, path),
+          members: [],
+          annotations: []
+        ).tap do |class_decl|
+          maps = {}
+
+          message.nested_type.each_with_index do |nested_type, index|
+            if nested_type.options&.map_entry
+              key_field, value_field = nested_type.field.to_a
+              map_type_name = ".#{(message_path + [nested_type.name]).join(".")}"
+              maps[map_type_name] = [key_field, value_field]
+            else
+              class_decl.members << message_to_decl(
+                nested_type,
+                prefix: RBS::Namespace.empty,
+                message_path: message_path + [nested_type.name.to_sym],
+                source_code_info: source_code_info,
+                path: path + [3, index]
+              )
+            end
+          end
+
+          message.enum_type.each_with_index do |enum, index|
+            class_decl.members << enum_type_to_decl(
+              enum,
+              prefix: RBS::Namespace.empty,
+              source_code_info: source_code_info,
+              path: path + [4, index]
+            )
+          end
+
+          field_read_types = {}
+          field_write_types = {}
+
+          message.field.each_with_index do |field, index|
+            field_name = field.name.to_sym
+            comment = comment_for_path(source_code_info, path + [2, index])
+
+            read_type, write_type = field_type(field, maps)
+
+            field_read_types[field_name] = read_type
+            field_write_types[field_name] = write_type
+
+            if read_type == write_type
+              class_decl.members << RBS::AST::Members::AttrAccessor.new(
+                name: field_name,
+                type: read_type,
+                comment: comment,
+                location: nil,
+                annotations: [],
+                ivar_name: false,
+                kind: :instance
+              )
+            else
+              class_decl.members << RBS::AST::Members::AttrReader.new(
+                name: field_name,
+                type: read_type,
+                comment: comment,
+                location: nil,
+                annotations: [],
+                ivar_name: false,
+                kind: :instance
+              )
+
+              class_decl.members << RBS::AST::Members::AttrWriter.new(
+                name: field_name,
+                type: write_type,
+                comment: comment,
+                location: nil,
+                annotations: [],
+                ivar_name: false,
+                kind: :instance
+              )
+            end
+          end
+
+          class_decl.members << RBS::AST::Members::MethodDefinition.new(
+            name: :initialize,
+            types: [
+              factory.method_type(
+                type: factory.function().update(
+                  optional_keywords: field_write_types.transform_values {|ty|
+                    factory.param(ty)
+                  }
+                )
+              )
+            ],
+            annotations: [],
+            comment: nil,
+            location: nil,
+            overload: false,
+            kind: :instance
+          )
+
+          unless field_read_types.empty?
+            class_decl.members << RBS::AST::Members::MethodDefinition.new(
+              name: :[],
+              types:
+                field_read_types.keys.map do |key|
+                  factory.method_type(
+                    type: factory.function(field_read_types[key]).update(
+                      required_positionals: [
+                        factory.param(factory.literal_type(key))
+                      ]
+                    )
+                  )
+                end +
+                  [
+                    factory.method_type(
+                      type: factory.function(factory.untyped).update(
+                        required_positionals: [
+                          factory.param(RBS::BuiltinNames::Symbol.instance_type)
+                        ]
+                      )
+                    )
+                  ],
+              annotations: [],
+              comment: nil,
+              location: nil,
+              overload: false,
+              kind: :instance
+            )
+          end
+
+          unless field_write_types.empty?
+            class_decl.members << RBS::AST::Members::MethodDefinition.new(
+              name: :[]=,
+              types:
+                field_write_types.keys.map do |key|
+                  factory.method_type(
+                    type: factory.function(field_write_types[key]).update(
+                      required_positionals: [
+                        factory.literal_type(key),
+                        field_write_types[key]
+                      ].map {|t| factory.param(t) }
+                    )
+                  )
+                end +
+                  [
+                    factory.method_type(
+                      type: factory.function(factory.untyped).update(
+                        required_positionals: [
+                          RBS::BuiltinNames::Symbol.instance_type,
+                          factory.untyped
+                        ].map {|t| factory.param(t) }
+                      )
+                    )
+                  ],
+              annotations: [],
+              comment: nil,
+              location: nil,
+              overload: false,
+              kind: :instance
+            )
+          end
+
+          message.field.each do |field|
+            if field.type == FieldDescriptorProto::Type::TYPE_BOOL
+              class_decl.members << RBS::AST::Members::MethodDefinition.new(
+                name: :"#{field.name}?",
+                types: [
+                  factory.method_type(
+                    type: factory.function(factory.bool_type)
+                  )
+                ],
+                annotations: [],
+                comment: nil,
+                location: nil,
+                overload: false,
+                kind: :instance
+              )
+            end
+          end
+        end
+      end
+
+      def field_type(field, maps)
+        case
+        when field.type == FieldDescriptorProto::Type::TYPE_MESSAGE
+          if maps.key?(field.type_name)
+            key_field, value_field = maps[field.type_name]
+
+            key_type_r, _ = field_type(key_field, maps)
+            value_type_r, value_type_w = field_type(value_field, maps)
+
+            hash_type = factory.instance_type(
+              factory.type_name("::Protobuf::Field::FieldHash"),
+              key_type_r,
+              factory.unwrap_optional(value_type_r),
+              factory.unwrap_optional(value_type_w)
+            )
+
+            [
+              hash_type,
+              hash_type
+            ]
+          else
+            type = message_type(field.type_name)
+
+            case field.label
+            when FieldDescriptorProto::Label::LABEL_OPTIONAL
+              type = factory.optional_type(type)
+              [type, type]
+            when FieldDescriptorProto::Label::LABEL_REPEATED
+              type = repeated_field_type(type)
+              [type, type]
+            else
+              [type, factory.optional_type(type)]
+            end
+          end
+        when field.type == FieldDescriptorProto::Type::TYPE_ENUM
+          type = message_type(field.type_name)
+          enum_namespace = type.name.to_namespace
+
+          wtype = factory.union_type(
+            type,
+            factory.alias_type(RBS::TypeName.new(name: :values, namespace: enum_namespace))
+          )
+
+          if field.label == FieldDescriptorProto::Label::LABEL_REPEATED
+            type = repeated_field_type(type, wtype)
+
+            [
+              type,
+              type
+            ]
+          else
+            [
+              type,
+              factory.optional_type(wtype)
+            ]
+          end
+        else
+          type = base_type(field.type)
+
+          if field.label == FieldDescriptorProto::Label::LABEL_REPEATED
+            type = repeated_field_type(type)
+            [type, type]
+          else
+            [type, factory.optional_type(type)]
+          end
+        end
+      end
+
+      def enum_base_class
+        RBS::AST::Declarations::Class::Super.new(
+          name: factory.type_name("::Protobuf::Enum"),
+          args: [],
+          location: nil
+        )
+      end
+
+      def enum_name(name)
+        if upcase_enum?
+          name.upcase.to_sym
+        else
+          name.to_sym
+        end
+      end
+
+      def enum_type_to_decl(enum_type, prefix:, source_code_info:, path:)
+        enum_name = ActiveSupport::Inflector.upcase_first(enum_type.name)
+
+        RBS::AST::Declarations::Class.new(
+          name: RBS::TypeName.new(name: enum_name.to_sym, namespace: prefix),
+          super_class: enum_base_class(),
+          type_params: factory.module_type_params(),
+          members: [],
+          comment: comment_for_path(source_code_info, path),
+          location: nil,
+          annotations: []
+        ).tap do |enum_decl|
+          names = enum_type.value.map do |v|
+            factory.literal_type(enum_name(v.name))
+          end
+
+          strings = enum_type.value.map do |v|
+            factory.literal_type(enum_name(v.name).to_s)
+          end
+
+          tags = enum_type.value.map do |v|
+            factory.literal_type(v.number)
+          end.uniq
+
+          enum_decl.members << RBS::AST::Declarations::Alias.new(
+            name: factory.type_name("names"),
+            type: factory.union_type(*names),
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+
+          enum_decl.members << RBS::AST::Declarations::Alias.new(
+            name: factory.type_name("strings"),
+            type: factory.union_type(*strings),
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+
+          enum_decl.members << RBS::AST::Declarations::Alias.new(
+            name: factory.type_name("tags"),
+            type: factory.union_type(*tags),
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+
+          enum_decl.members << RBS::AST::Declarations::Alias.new(
+            name: factory.type_name("values"),
+            type: factory.union_type(
+              factory.alias_type("names"),
+              factory.alias_type("strings"),
+              factory.alias_type("tags")
+            ),
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+
+          enum_decl.members << RBS::AST::Members::AttrReader.new(
+            name: :name,
+            type: factory.alias_type("names"),
+            ivar_name: false,
+            annotations: [],
+            comment: nil,
+            location: nil,
+            kind: :instance
+          )
+
+          enum_decl.members << RBS::AST::Members::AttrReader.new(
+            name: :tag,
+            type: factory.alias_type("tags"),
+            ivar_name: false,
+            annotations: [],
+            comment: nil,
+            location: nil,
+            kind: :instance
+          )
+
+          enum_type.value.each.with_index do |v, index|
+            comment = comment_for_path(source_code_info, path + [2, index])
+
+            enum_decl.members << RBS::AST::Declarations::Constant.new(
+              name: factory.type_name(enum_name(v.name).to_s),
+              type: RBS::TypeName.new(name: enum_name.to_sym, namespace: prefix),
+              comment: comment,
+              location: nil
+            )
+          end
+        end
+      end
+
+      def extension_to_decl(extendee_name, extensions, prefix:, source_code_info:, path:)
+        class_name = message_type(extendee_name).name
+
+        extensions.map do |field|
+          field_name = field.name.to_sym
+
+          RBS::AST::Declarations::Class.new(
+            name: class_name,
+            super_class: nil,
+            type_params: RBS::AST::Declarations::ModuleTypeParams.empty,
+            location: nil,
+            comment: nil,
+            members: [],
+            annotations: []
+          ).tap do |class_decl|
+            read_type, write_type = field_type(field, {})
+
+            if read_type == write_type
+              class_decl.members << RBS::AST::Members::AttrAccessor.new(
+                name: field_name,
+                type: read_type,
+                comment: nil,
+                location: nil,
+                annotations: [],
+                ivar_name: false,
+                kind: :instance
+              )
+            else
+              class_decl.members << RBS::AST::Members::AttrReader.new(
+                name: field_name,
+                type: read_type,
+                comment: nil,
+                location: nil,
+                annotations: [],
+                ivar_name: false,
+                kind: :instance
+              )
+
+              class_decl.members << RBS::AST::Members::AttrWriter.new(
+                name: field_name,
+                type: write_type,
+                comment: nil,
+                location: nil,
+                annotations: [],
+                ivar_name: false,
+                kind: :instance
+              )
+            end
+
+            class_decl.members << RBS::AST::Members::MethodDefinition.new(
+              name: :[],
+              types: [
+                factory.method_type(
+                  type: factory.function(read_type).update(
+                    required_positionals: [
+                      factory.param(factory.literal_type(field_name))
+                    ]
+                  )
+                )
+              ],
+              annotations: [],
+              comment: nil,
+              location: nil,
+              overload: true,
+              kind: :instance
+            )
+
+            class_decl.members << RBS::AST::Members::MethodDefinition.new(
+              name: :[]=,
+              types: [
+                factory.method_type(
+                  type: factory.function(write_type).update(
+                    required_positionals: [
+                      factory.param(factory.literal_type(field_name)),
+                      factory.param(write_type)
+                    ]
+                  )
+                )
+              ],
+              annotations: [],
+              comment: nil,
+              location: nil,
+              overload: true,
+              kind: :instance
+            )
+          end
+        end
+      end
+
+      def service_base_class
+        RBS::AST::Declarations::Class::Super.new(
+          name: factory.type_name("::Protobuf::Rpc::Service"),
+          args: [],
+          location: nil
+        )
+      end
+
+      def service_to_decl(service, prefix:, source_code_info:, path:)
+        service_name = ActiveSupport::Inflector.camelize(service.name)
+
+        RBS::AST::Declarations::Class.new(
+          name: RBS::TypeName.new(name: service_name.to_sym, namespace: prefix),
+          super_class: service_base_class,
+          type_params: factory.module_type_params(),
+          members: [],
+          comment: comment_for_path(source_code_info, path),
+          location: nil,
+          annotations: []
+        )
+      end
+    end
+  end
+end