rbs_protobuf 1.0.0 → 1.2.0

data/lib/rbs_protobuf/translator/protobuf_gem.rb

@@ -19,8 +19,8 @@ module RBSProtobuf
 
       attr_reader :accept_nil_writer
 
-      def initialize(input, upcase_enum:, nested_namespace:, extension:, accept_nil_writer:, stderr: STDERR)
-        super(input)
+      def initialize(input, filters=[], upcase_enum:, nested_namespace:, extension:, accept_nil_writer:, stderr: STDERR)
+        super(input, filters)
         @upcase_enum = upcase_enum
         @nested_namespace = nested_namespace
         @extension = extension
@@ -49,7 +49,7 @@ module RBSProtobuf
       end
 
       def rbs_content(file)
-        decls = []
+        decls = [] #: Array[RBS::AST::Declarations::t]
 
         source_code_info = file.source_code_info
 
@@ -127,9 +127,7 @@ module RBSProtobuf
           end
         end
 
-        StringIO.new.tap do |io|
-          RBS::Writer.new(out: io).write(decls)
-        end.string
+        decls
       end
 
       def message_to_decl(message, prefix:, message_path:, source_code_info:, path:)
@@ -188,96 +186,124 @@ module RBSProtobuf
 
           class_decl.members << RBS::AST::Members::MethodDefinition.new(
             name: :initialize,
-            types: [
-              factory.method_type(
-                type: factory.function().update(
-                  optional_keywords: field_types.transform_values {|pair|
-                    _, _, init_type = pair
-                    factory.param(init_type)
-                  }
+            overloads: [
+              RBS::AST::Members::MethodDefinition::Overload.new(
+                method_type: factory.method_type(
+                  type: factory.function().update(
+                    optional_keywords: field_types.transform_values {|pair|
+                      _, _, init_type = pair
+                      factory.param(init_type)
+                    }
+                  )
+                ),
+                annotations: []
+              ),
+              unless field_types.empty?
+                RBS::AST::Members::MethodDefinition::Overload.new(
+                  method_type: factory.method_type(
+                    type: factory.function().update(
+                      required_positionals: [factory.param(factory.alias_type("record"))]
+                    )
+                  ),
+                  annotations: []
                 )
-              )
-            ],
+              end,
+            ].compact,
             annotations: [],
             comment: nil,
             location: nil,
-            overload: false,
+            overloading: false,
+            visibility: nil,
             kind: :instance
           )
 
           unless field_types.empty?
             class_decl.members << RBS::AST::Members::MethodDefinition.new(
               name: :[],
-              types:
+              overloads:
                 field_types.map do |field_name, pair|
                   read_type, _ = pair
 
-                  factory.method_type(
-                    type: factory.function(read_type).update(
-                      required_positionals: [
-                        factory.param(factory.literal_type(field_name))
-                      ]
-                    )
-                  )
-                end +
-                  [
-                    factory.method_type(
-                      type: factory.function(factory.untyped).update(
+                  RBS::AST::Members::MethodDefinition::Overload.new(
+                    method_type: factory.method_type(
+                      type: factory.function(read_type).update(
                         required_positionals: [
-                          factory.param(RBS::BuiltinNames::Symbol.instance_type)
+                          factory.param(factory.literal_type(field_name))
                         ]
                       )
+                    ),
+                    annotations: []
+                  )
+                end +
+                  [
+                    RBS::AST::Members::MethodDefinition::Overload.new(
+                      method_type: factory.method_type(
+                        type: factory.function(factory.untyped).update(
+                          required_positionals: [
+                            factory.param(RBS::BuiltinNames::Symbol.instance_type)
+                          ]
+                        )
+                      ),
+                      annotations: []
                     )
                   ],
               annotations: [],
               comment: nil,
               location: nil,
-              overload: false,
+              overloading: false,
+              visibility: nil,
               kind: :instance
             )
 
             class_decl.members << RBS::AST::Members::MethodDefinition.new(
               name: :[]=,
-              types:
+              overloads:
                 field_types.flat_map do |field_name, pair|
                   read_type, write_types = pair
 
                   [read_type, *write_types].map do |type|
-                    if (type_param, type_var = interface_type?(type))
-                      factory.method_type(
-                        type: factory.function(type_var).update(
-                          required_positionals: [
-                            factory.literal_type(field_name),
-                            type_var
-                          ].map {|t| factory.param(t) }
-                        )
-                      ).update(type_params: [type_param])
-                    else
-                      factory.method_type(
-                        type: factory.function(type).update(
-                          required_positionals: [
-                            factory.literal_type(field_name),
-                            type
-                          ].map {|t| factory.param(t) }
+                    method_type =
+                      if (type_param, type_var = interface_type?(type))
+                        factory.method_type(
+                          type: factory.function(type_var).update(
+                            required_positionals: [
+                              factory.literal_type(field_name),
+                              type_var
+                            ].map {|t| factory.param(t) }
+                          )
+                        ).update(type_params: [type_param])
+                      else
+                        factory.method_type(
+                          type: factory.function(type).update(
+                            required_positionals: [
+                              factory.literal_type(field_name),
+                              type
+                            ].map {|t| factory.param(t) }
+                          )
                         )
-                      )
-                    end
+                      end
+
+                    RBS::AST::Members::MethodDefinition::Overload.new(method_type: method_type, annotations: [])
                   end
                 end +
                   [
-                    factory.method_type(
-                      type: factory.function(factory.untyped).update(
-                        required_positionals: [
-                          RBS::BuiltinNames::Symbol.instance_type,
-                          factory.untyped
-                        ].map {|t| factory.param(t) }
-                      )
+                    RBS::AST::Members::MethodDefinition::Overload.new(
+                      method_type: factory.method_type(
+                        type: factory.function(factory.untyped).update(
+                          required_positionals: [
+                            RBS::BuiltinNames::Symbol.instance_type,
+                            factory.untyped
+                          ].map {|t| factory.param(t) }
+                        )
+                      ),
+                      annotations: []
                     )
                   ],
               annotations: [],
               comment: nil,
               location: nil,
-              overload: false,
+              overloading: false,
+              visibility: nil,
               kind: :instance
             )
           end
@@ -286,15 +312,19 @@ module RBSProtobuf
             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)
+                overloads: [
+                  RBS::AST::Members::MethodDefinition::Overload.new(
+                    method_type: factory.method_type(
+                      type: factory.function(factory.bool_type)
+                    ),
+                    annotations: []
                   )
                 ],
                 annotations: [],
                 comment: nil,
                 location: nil,
-                overload: false,
+                overloading: false,
+                visibility: nil,
                 kind: :instance
               )
             end
@@ -310,29 +340,37 @@ module RBSProtobuf
           ).tap do |interface_decl|
             interface_decl.members << RBS::AST::Members::MethodDefinition.new(
               name: :to_proto,
-              types: [
-                factory.method_type(
-                  type: factory.function(class_instance_type)
+              overloads: [
+                RBS::AST::Members::MethodDefinition::Overload.new(
+                  method_type: factory.method_type(
+                    type: factory.function(class_instance_type)
+                  ),
+                  annotations: []
                 )
               ],
               annotations: [],
               comment: nil,
               location: nil,
-              overload: false,
+              overloading: false,
+              visibility: nil,
               kind: :instance
             )
           end
 
-          class_decl.members << RBS::AST::Declarations::Alias.new(
+          class_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("init"),
             type_params: [],
-            type: factory.union_type(class_instance_type, TO_PROTO[]),
+            type: factory.union_type(
+              class_instance_type,
+              TO_PROTO[],
+              field_types.empty? ? nil : factory.alias_type("record")
+            ),
             annotations: [],
             comment: RBS::AST::Comment.new(string: "The type of `#initialize` parameter.", location: nil),
             location: nil
           )
 
-          class_decl.members << RBS::AST::Declarations::Alias.new(
+          class_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("field_array"),
             type_params: [],
             type: FIELD_ARRAY[
@@ -344,7 +382,7 @@ module RBSProtobuf
             location: nil
           )
 
-          class_decl.members << RBS::AST::Declarations::Alias.new(
+          class_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("field_hash"),
             type_params: [RBS::AST::TypeParam.new(name: :KEY, variance: :invariant, upper_bound: nil, location: nil)],
             type: FIELD_HASH[
@@ -357,7 +395,7 @@ module RBSProtobuf
             location: nil
           )
 
-          class_decl.members << RBS::AST::Declarations::Alias.new(
+          class_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("array"),
             type_params: [],
             type: RBS::BuiltinNames::Array.instance_type(factory.union_type(class_instance_type, TO_PROTO[])),
@@ -366,7 +404,7 @@ module RBSProtobuf
             location: nil
           )
 
-          class_decl.members << RBS::AST::Declarations::Alias.new(
+          class_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("hash"),
             type_params: [RBS::AST::TypeParam.new(name: :KEY, variance: :invariant, upper_bound: nil, location: nil)],
             type: RBS::BuiltinNames::Hash.instance_type(
@@ -377,6 +415,18 @@ module RBSProtobuf
             comment: nil,
             location: nil
           )
+
+          class_decl.members << RBS::AST::Declarations::TypeAlias.new(
+            name: TypeName("record"),
+            type_params: [],
+            type: RBS::Types::Record.new(
+              fields: field_types.transform_values {|_, _, type| optional_type(type) },
+              location: nil
+              ),
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
         end
       end
 
@@ -567,41 +617,52 @@ module RBSProtobuf
         unless write_types.empty?
           members << RBS::AST::Members::MethodDefinition.new(
             name: :"#{name}=",
-            types:
+            overloads:
               write_types.map do |write_type|
-                if (type_param, type = interface_type?(write_type))
-                  factory.method_type(
-                    type: factory.function(type).update(
-                      required_positionals:[factory.param(type)]
-                    )
-                  ).update(type_params: [type_param])
-                else
-                  factory.method_type(
-                    type: factory.function(write_type).update(
-                      required_positionals:[factory.param(write_type)]
+                method_type =
+                  if (type_param, type = interface_type?(write_type))
+                    factory.method_type(
+                      type: factory.function(type).update(
+                        required_positionals:[factory.param(type)]
+                      )
+                    ).update(type_params: [type_param])
+                  else
+                    factory.method_type(
+                      type: factory.function(write_type).update(
+                        required_positionals:[factory.param(write_type)]
+                      )
                     )
-                  )
-                end
+                  end
+
+                RBS::AST::Members::MethodDefinition::Overload.new(
+                  method_type: method_type,
+                  annotations: []
+                )
               end,
             annotations: [],
             comment: comment,
             location: nil,
-            overload: true,
+            overloading: true,
+            visibility: nil,
             kind: :instance
           )
         end
 
         members << RBS::AST::Members::MethodDefinition.new(
           name: :"#{name}!",
-          types: [
-            factory.method_type(
-              type: factory.function(factory.optional_type(read_type))
+          overloads: [
+            RBS::AST::Members::MethodDefinition::Overload.new(
+              method_type: factory.method_type(
+                type: factory.function(factory.optional_type(read_type))
+              ),
+              annotations: []
             )
           ],
           annotations: [],
           comment: nil,
           location: nil,
-          overload: false,
+          overloading: false,
+          visibility: nil,
           kind: :instance
         )
       end
@@ -638,7 +699,7 @@ module RBSProtobuf
             factory.literal_type(v.number)
           end.uniq
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: factory.type_name("names"),
             type_params: [],
             type: factory.union_type(*names),
@@ -647,7 +708,7 @@ module RBSProtobuf
             annotations: []
           )
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: factory.type_name("strings"),
             type_params: [],
             type: factory.union_type(*strings),
@@ -656,7 +717,7 @@ module RBSProtobuf
             annotations: []
           )
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: factory.type_name("tags"),
             type_params: [],
             type: factory.union_type(*tags),
@@ -665,7 +726,7 @@ module RBSProtobuf
             annotations: []
           )
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: factory.type_name("values"),
             type_params: [],
             type: factory.union_type(
@@ -712,7 +773,7 @@ module RBSProtobuf
           enum_instance_type = factory.instance_type(RBS::TypeName.new(name: enum_name.to_sym, namespace: RBS::Namespace.empty))
           values_type = factory.alias_type(RBS::TypeName.new(name: :values, namespace: RBS::Namespace.empty))
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("init"),
             type_params: [],
             type: factory.union_type(enum_instance_type, values_type),
@@ -721,7 +782,7 @@ module RBSProtobuf
             location: nil
           )
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("field_array"),
             type_params: [],
             type: FIELD_ARRAY[
@@ -733,7 +794,7 @@ module RBSProtobuf
             location: nil
           )
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("field_hash"),
             type_params: [RBS::AST::TypeParam.new(name: :KEY, variance: :invariant, upper_bound: nil, location: nil)],
             type: FIELD_HASH[
@@ -746,7 +807,7 @@ module RBSProtobuf
             location: nil
           )
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("array"),
             type_params: [],
             type: RBS::BuiltinNames::Array.instance_type(factory.union_type(enum_instance_type, values_type)),
@@ -755,7 +816,7 @@ module RBSProtobuf
             location: nil
           )
 
-          enum_decl.members << RBS::AST::Declarations::Alias.new(
+          enum_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("hash"),
             type_params: [RBS::AST::TypeParam.new(name: :KEY, variance: :invariant, upper_bound: nil, location: nil)],
             type: RBS::BuiltinNames::Hash.instance_type(
@@ -790,49 +851,59 @@ module RBSProtobuf
 
           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))
-                  ]
-                )
+            overloads: [
+              RBS::AST::Members::MethodDefinition::Overload.new(
+                method_type: factory.method_type(
+                  type: factory.function(read_type).update(
+                    required_positionals: [
+                      factory.param(factory.literal_type(field_name))
+                    ]
+                  )
+                ),
+                annotations: []
               )
             ],
             annotations: [],
             comment: nil,
             location: nil,
-            overload: true,
+            overloading: true,
+            visibility: nil,
             kind: :instance
           )
 
           class_decl.members << RBS::AST::Members::MethodDefinition.new(
             name: :[]=,
-            types: [read_type, *write_types].map do |write_type|
-              if (type_param, type_var = interface_type?(write_type))
-                factory.method_type(
-                  type: factory.function(type_var).update(
-                    required_positionals: [
-                      factory.param(factory.literal_type(field_name)),
-                      factory.param(type_var)
-                    ]
-                  )
-                ).update(type_params: [type_param])
-              else
-                factory.method_type(
-                  type: factory.function(write_type).update(
-                    required_positionals: [
-                      factory.param(factory.literal_type(field_name)),
-                      factory.param(write_type)
-                    ]
+            overloads: [read_type, *write_types].map do |write_type|
+              method_type =
+                if (type_param, type_var = interface_type?(write_type))
+                  factory.method_type(
+                    type: factory.function(type_var).update(
+                      required_positionals: [
+                        factory.param(factory.literal_type(field_name)),
+                        factory.param(type_var)
+                      ]
+                    )
+                  ).update(type_params: [type_param])
+                else
+                  factory.method_type(
+                    type: factory.function(write_type).update(
+                      required_positionals: [
+                        factory.param(factory.literal_type(field_name)),
+                        factory.param(write_type)
+                      ]
+                    )
                   )
-                )
-              end
+                end
+              RBS::AST::Members::MethodDefinition::Overload.new(
+                method_type: method_type,
+                annotations: []
+              )
             end,
             annotations: [],
             comment: nil,
             location: nil,
-            overload: true,
+            overloading: true,
+            visibility: nil,
             kind: :instance
           )
         end
@@ -849,11 +920,81 @@ module RBSProtobuf
       def service_to_decl(service, prefix:, source_code_info:, path:)
         service_name = ActiveSupport::Inflector.camelize(service.name)
 
+        members = [] #: Array[RBS::AST::Declarations::Class::member]
+
+        service.method.each do |method|
+          method_name = ActiveSupport::Inflector.underscore(method.name).to_sym #: Symbol
+
+          interface_name = "_#{ActiveSupport::Inflector.camelize(method.name)}Method"
+
+          members << RBS::AST::Declarations::Interface.new(
+            name: factory.type_name(interface_name),
+            type_params: [],
+            members: [
+              RBS::AST::Members::MethodDefinition.new(
+                name: :request,
+                kind: :instance,
+                overloads: [
+                  RBS::AST::Members::MethodDefinition::Overload.new(
+                    method_type: factory.method_type(type: factory.function(message_type(method.input_type))),
+                    annotations: []
+                  )
+                ],
+                annotations: [],
+                location: nil,
+                comment: nil,
+                overloading: false,
+                visibility: nil
+              ),
+              RBS::AST::Members::MethodDefinition.new(
+                name: :respond_with,
+                kind: :instance,
+                overloads: [
+                  RBS::AST::Members::MethodDefinition::Overload.new(
+                    method_type: factory.method_type(
+                      type: factory.function().update(
+                        required_positionals: [
+                          factory.param(message_init_type(message_type(method.output_type)))
+                        ]
+                      )
+                    ),
+                    annotations: []
+                  )
+                ],
+                annotations: [],
+                location: nil,
+                comment: nil,
+                overloading: false,
+                visibility: nil
+              )
+            ],
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
+
+          members << RBS::AST::Members::MethodDefinition.new(
+            name: method_name,
+            kind: :instance,
+            overloads: [
+              RBS::AST::Members::MethodDefinition::Overload.new(
+                method_type: factory.method_type(type: factory.function()),
+                annotations: []
+              )
+            ],
+            annotations: [],
+            location: nil,
+            comment: nil,
+            overloading: false,
+            visibility: nil
+          )
+        end
+
         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: [],
+          members: members,
           comment: comment_for_path(source_code_info, path, options: nil),
           location: nil,
           annotations: []

data/lib/rbs_protobuf/version.rb

@@ -1,3 +1,3 @@
 module RBSProtobuf
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end