rbs-inline 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c6ea86390a9ce51331956c34fb2eedc77ae45c4ac0fc7b39d67f2cacb2a5af0
-  data.tar.gz: 9e1446ab0920edec03ed54a1a07c8868e3dac9529813c389ed35f85f0380e7c9
+  metadata.gz: ae1ebe5ac15f3f5c12c3b162fbcdc754de5544867fbc2d455af7a2028bfc12c7
+  data.tar.gz: aecd4c155a61ff168e9dea24d22cd9772566b26d973ffe9857e85f369e716a32
 SHA512:
-  metadata.gz: 793f9e99431ac027e1ccf6d3b2b31ead740b9227584aa5be5f751cd1eafea85ce8db37e070b5dfcde28139f629d2c2a499aa5e2d507fcbe53c7fd8a3e9cf2377
-  data.tar.gz: 3f74d9a9a96189fcd21c470aa7b97949fa625dbb46b218c6ae993b049993947d7a27840755af43626702aa6b55cebc1a25d70830343c6f954bcb2694f30fc34b
+  metadata.gz: ffb76bf31d5c65a4e50edc61bd5538214d15fca1c4bcf0be83a86c32fbb22f27f5947279bec2919aee94928c236605f3998395a9c4b8f2329f0fe933bdff4e87
+  data.tar.gz: 7dd187fd1519420e823133a84abb6fc858ac6e8024b899b96a0e6cd6c581b42c332e161e9af67067224d9b95d939e32900eeeb5e61b3c5d405b94433e0c19d17

data/lib/rbs/inline/ast/annotations.rb

@@ -404,6 +404,12 @@ module RBS
               token[1]
             end
           end
+
+          def annotations #: Array[RBS::AST::Annotation]
+            contents.map do |content|
+              RBS::AST::Annotation.new(string: content[3..-2] || raise, location: nil)
+            end
+          end
         end
 
         # `# @rbs skip`

data/lib/rbs/inline/ast/declarations.rb

@@ -13,10 +13,22 @@ module RBS
               TypeName(node.full_name)
             end
           end
+
+          # @rbs (Prism::Node) -> Prism::Node?
+          def value_node(node)
+            case node
+            when Prism::ConstantWriteNode
+              value_node(node.value)
+            when Prism::LocalVariableWriteNode
+              value_node(node.value)
+            else
+              node
+            end
+          end
         end
 
         # @rbs!
-        #   type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl | BlockDecl
+        #   type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl | BlockDecl | DataAssignDecl | StructAssignDecl
         #
         #  interface _WithComments
         #    def comments: () -> AnnotationParser::ParsingResult?
@@ -229,6 +241,21 @@ module RBS
         end
 
         class SingletonClassDecl < ModuleOrClass #[Prism::SingletonClassNode]
+          # @rbs (AST::Members::RubyDef) -> (:private | nil)
+          def visibility(def_member)
+            current_visibility = nil
+            members.each do |member|
+              case member
+              when AST::Members::RubyPublic
+                current_visibility = nil
+              when AST::Members::RubyPrivate
+                current_visibility = :private
+              end
+
+              break if member == def_member
+            end
+            current_visibility
+          end
         end
 
         class BlockDecl < Base
@@ -266,6 +293,231 @@ module RBS
             end
           end
         end
+
+        # @rbs module-self _WithTypeDecls
+        module DataStructUtil
+          # @rbs!
+          #   interface _WithTypeDecls
+          #     def type_decls: () -> Hash[Integer, Annotations::TypeAssertion]
+          #
+          #     def each_attribute_argument: () { (Prism::Node) -> void } -> void
+          #
+          #     def comments: %a{pure} () -> AnnotationParser::ParsingResult?
+          #   end
+
+          # @rbs %a{pure}
+          # @rbs () { ([Symbol, Annotations::TypeAssertion?]) -> void } -> void
+          #    | () -> Enumerator[[Symbol, Annotations::TypeAssertion?], void]
+          def each_attribute(&block)
+            if block
+              each_attribute_argument do |arg|
+                if arg.is_a?(Prism::SymbolNode)
+                  if name = arg.value
+                    type = type_decls.fetch(arg.location.start_line, nil)
+                    yield [name.to_sym, type]
+                  end
+                end
+              end
+            else
+              enum_for :each_attribute
+            end
+          end
+
+          def class_annotations #: Array[RBS::AST::Annotation]
+            annotations = [] #: Array[RBS::AST::Annotation]
+
+            comments&.each_annotation do |annotation|
+              if annotation.is_a?(Annotations::RBSAnnotation)
+                annotations.concat annotation.annotations
+              end
+            end
+
+            annotations
+          end
+        end
+
+        class DataAssignDecl < Base
+          extend ConstantUtil
+
+          include DataStructUtil
+
+          attr_reader :node #: Prism::ConstantWriteNode
+
+          attr_reader :comments #: AnnotationParser::ParsingResult?
+
+          attr_reader :type_decls #: Hash[Integer, Annotations::TypeAssertion]
+
+          attr_reader :data_define_node #: Prism::CallNode
+
+          # @rbs (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+          def initialize(node, data_define_node, comments, type_decls)
+            @node = node
+            @comments = comments
+            @type_decls = type_decls
+            @data_define_node = data_define_node
+          end
+
+          def start_line #: Integer
+            node.location.start_line
+          end
+
+          # @rbs %a{pure}
+          # @rbs () -> TypeName?
+          def constant_name
+            TypeName.new(name: node.name, namespace: Namespace.empty)
+          end
+
+          # @rbs (Prism::ConstantWriteNode) -> Prism::CallNode?
+          def self.data_define?(node)
+            value = value_node(node)
+
+            if value.is_a?(Prism::CallNode)
+              if value.receiver.is_a?(Prism::ConstantReadNode)
+                if value.receiver.full_name.delete_prefix("::") == "Data"
+                  if value.name == :define
+                    return value
+                  end
+                end
+              end
+            end
+          end
+
+          # @rbs () { (Prism::Node) -> void } -> void
+          def each_attribute_argument(&block)
+            if args = data_define_node.arguments
+              args.arguments.each(&block)
+            end
+          end
+        end
+
+        class StructAssignDecl < Base
+          extend ConstantUtil
+
+          include DataStructUtil
+
+          attr_reader :node #: Prism::ConstantWriteNode
+
+          attr_reader :comments #: AnnotationParser::ParsingResult?
+
+          attr_reader :type_decls #: Hash[Integer, Annotations::TypeAssertion]
+
+          attr_reader :struct_new_node #: Prism::CallNode
+
+          # @rbs (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+          def initialize(node, struct_new_node, comments, type_decls)
+            @node = node
+            @comments = comments
+            @type_decls = type_decls
+            @struct_new_node = struct_new_node
+          end
+
+          def start_line #: Integer
+            node.location.start_line
+          end
+
+          # @rbs %a{pure}
+          # @rbs () -> TypeName?
+          def constant_name
+            TypeName.new(name: node.name, namespace: Namespace.empty)
+          end
+
+          # @rbs () { (Prism::Node) -> void } -> void
+          def each_attribute_argument(&block)
+            if args = struct_new_node.arguments
+              args.arguments.each do |arg|
+                next if arg.is_a?(Prism::KeywordHashNode)
+                next if arg.is_a?(Prism::StringNode)
+
+                yield arg
+              end
+            end
+          end
+
+          # @rbs (Prism::ConstantWriteNode) -> Prism::CallNode?
+          def self.struct_new?(node)
+            value = value_node(node)
+
+            if value.is_a?(Prism::CallNode)
+              if value.receiver.is_a?(Prism::ConstantReadNode)
+                if value.receiver.full_name.delete_prefix("::") == "Struct"
+                  if value.name == :new
+                    return value
+                  end
+                end
+              end
+            end
+          end
+
+          # @rbs %a{pure}
+          def keyword_init? #: bool
+            if args = struct_new_node.arguments
+              args.arguments.each do |arg|
+                if arg.is_a?(Prism::KeywordHashNode)
+                  arg.elements.each do |assoc|
+                    if assoc.is_a?(Prism::AssocNode)
+                      if (key = assoc.key).is_a?(Prism::SymbolNode)
+                        if key.value == "keyword_init"
+                          value = assoc.value
+                          if value.is_a?(Prism::FalseNode)
+                            return false
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            true
+          end
+
+          # @rbs %a{pure}
+          def positional_init? #: bool
+            if args = struct_new_node.arguments
+              args.arguments.each do |arg|
+                if arg.is_a?(Prism::KeywordHashNode)
+                  arg.elements.each do |assoc|
+                    if assoc.is_a?(Prism::AssocNode)
+                      if (key = assoc.key).is_a?(Prism::SymbolNode)
+                        if key.value == "keyword_init"
+                          value = assoc.value
+                          if value.is_a?(Prism::TrueNode)
+                            return false
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            true
+          end
+
+          # Returns `true` is annotation is given to make all attributes *readonly*
+          #
+          # Add `# @rbs %a{rbs-inline:readonly-attributes=true}` to the class to make all attributes `attr_reader`, instead of `attr_accessor`.
+          #
+          # @rbs %a{pure}
+          def readonly_attributes? #: bool
+            class_annotations.any? do |annotation|
+              annotation.string == "rbs-inline:readonly-attributes=true"
+            end
+          end
+
+          # Returns `true` if annotation is given to make all `.new` arguments required
+          #
+          # Add `# @rbs %a{rbs-inline:new-args=required}` to the class to make all of the parameters required.
+          #
+          # @rbs %a{pure}
+          def required_new_args? #: bool
+            class_annotations.any? do |annotation|
+              annotation.string == "rbs-inline:new-args=required"
+            end
+          end
+        end
       end
     end
   end

data/lib/rbs/inline/ast/members.rb

@@ -277,12 +277,7 @@ module RBS
             if comments
               comments.each_annotation.flat_map do |annotation|
                 if annotation.is_a?(AST::Annotations::RBSAnnotation)
-                  annotation.contents.map do |string|
-                    RBS::AST::Annotation.new(
-                      string: string[3...-1] || "",
-                      location: nil
-                    )
-                  end
+                  annotation.annotations
                 else
                   []
                 end

data/lib/rbs/inline/parser.rb

@@ -417,9 +417,38 @@ module RBS
         return if ignored_node?(node)
 
         comment = comments.delete(node.location.start_line - 1)
-        assertion = assertion_annotation(node)
 
-        decl = AST::Declarations::ConstantDecl.new(node, comment, assertion)
+        case
+        when data_node = AST::Declarations::DataAssignDecl.data_define?(node)
+          type_decls = {} #: Hash[Integer, AST::Annotations::TypeAssertion]
+
+          inner_annotations(node.location.start_line, node.location.end_line).flat_map do |comment|
+            comment.each_annotation do |annotation|
+              if annotation.is_a?(AST::Annotations::TypeAssertion)
+                start_line = annotation.source.comments[0].location.start_line
+                type_decls[start_line] = annotation
+              end
+            end
+          end
+
+          decl = AST::Declarations::DataAssignDecl.new(node, data_node, comment, type_decls)
+        when struct_node = AST::Declarations::StructAssignDecl.struct_new?(node)
+          type_decls = {} #: Hash[Integer, AST::Annotations::TypeAssertion]
+
+          inner_annotations(node.location.start_line, node.location.end_line).flat_map do |comment|
+            comment.each_annotation do |annotation|
+              if annotation.is_a?(AST::Annotations::TypeAssertion)
+                start_line = annotation.source.comments[0].location.start_line
+                type_decls[start_line] = annotation
+              end
+            end
+          end
+
+          decl = AST::Declarations::StructAssignDecl.new(node, struct_node, comment, type_decls)
+        else
+          assertion = assertion_annotation(node)
+          decl = AST::Declarations::ConstantDecl.new(node, comment, assertion)
+        end
 
         if current = current_class_module_decl
           current.members << decl

data/lib/rbs/inline/version.rb

@@ -2,6 +2,6 @@
 
 module RBS
   module Inline
-    VERSION = "0.5.0"
+    VERSION = "0.7.0"
   end
 end

data/lib/rbs/inline/writer.rb

@@ -77,6 +77,10 @@ module RBS
           translate_module_decl(decl, rbs)
         when AST::Declarations::ConstantDecl
           translate_constant_decl(decl, rbs)
+        when AST::Declarations::DataAssignDecl
+          translate_data_assign_decl(decl, rbs)
+        when AST::Declarations::StructAssignDecl
+          translate_struct_assign_decl(decl, rbs)
         when AST::Declarations::BlockDecl
           if decl.module_class_annotation
             case decl.module_class_annotation
@@ -131,7 +135,7 @@ module RBS
             else
               translate_members(member.members, decl, rbs)
             end
-          when AST::Declarations::ClassDecl, AST::Declarations::ModuleDecl, AST::Declarations::ConstantDecl
+          when AST::Declarations::ClassDecl, AST::Declarations::ModuleDecl, AST::Declarations::ConstantDecl, AST::Declarations::DataAssignDecl, AST::Declarations::StructAssignDecl
             translate_decl(member, rbs)
           end
         end
@@ -182,6 +186,202 @@ module RBS
         )
       end
 
+      # @rbs decl: AST::Declarations::DataAssignDecl
+      # @rbs rbs: _Content
+      def translate_data_assign_decl(decl, rbs) #: void
+        return unless decl.constant_name
+
+        if decl.comments
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
+        end
+
+        attributes = decl.each_attribute.map do |name, type|
+          RBS::AST::Members::AttrReader.new(
+            name: name,
+            type: type&.type || Types::Bases::Any.new(location: nil),
+            ivar_name: false,
+            comment: nil,
+            kind: :instance,
+            annotations: [],
+            visibility: nil,
+            location: nil
+          )
+        end
+
+        new = RBS::AST::Members::MethodDefinition.new(
+          name: :new,
+          kind: :singleton,
+          overloads: [
+            RBS::AST::Members::MethodDefinition::Overload.new(
+              method_type: RBS::MethodType.new(
+                type_params: [],
+                type: Types::Function.empty(Types::Bases::Instance.new(location: nil)).update(
+                  required_positionals: decl.each_attribute.map do |name, attr|
+                    RBS::Types::Function::Param.new(
+                      type: attr&.type || Types::Bases::Any.new(location: nil),
+                      name: name,
+                      location: nil
+                    )
+                  end
+                ),
+                block: nil,
+                location: nil
+              ),
+              annotations: []
+            ),
+            RBS::AST::Members::MethodDefinition::Overload.new(
+              method_type: RBS::MethodType.new(
+                type_params: [],
+                type: Types::Function.empty(Types::Bases::Instance.new(location: nil)).update(
+                  required_keywords: decl.each_attribute.map do |name, attr|
+                    [
+                      name,
+                      RBS::Types::Function::Param.new(
+                        type: attr&.type || Types::Bases::Any.new(location: nil),
+                        name: nil,
+                        location: nil
+                      )
+                    ]
+                  end.to_h
+                ),
+                block: nil,
+                location: nil
+              ),
+              annotations: []
+            )
+          ],
+          annotations: [],
+          location: nil,
+          comment: nil,
+          overloading: false,
+          visibility: nil
+        )
+
+        rbs << RBS::AST::Declarations::Class.new(
+          name: decl.constant_name,
+          type_params: [],
+          members: [*attributes, new],
+          super_class: RBS::AST::Declarations::Class::Super.new(
+            name: RBS::TypeName.new(name: :Data, namespace: RBS::Namespace.empty),
+            args: [],
+            location: nil
+          ),
+          annotations: decl.class_annotations,
+          location: nil,
+          comment: comment
+        )
+      end
+
+      # @rbs decl: AST::Declarations::StructAssignDecl
+      # @rbs rbs: _Content
+      def translate_struct_assign_decl(decl, rbs) #: void
+        return unless decl.constant_name
+
+        if decl.comments
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
+        end
+
+        attributes = decl.each_attribute.map do |name, type|
+          if decl.readonly_attributes?
+            RBS::AST::Members::AttrReader.new(
+              name: name,
+              type: type&.type || Types::Bases::Any.new(location: nil),
+              ivar_name: false,
+              comment: nil,
+              kind: :instance,
+              annotations: [],
+              visibility: nil,
+              location: nil
+            )
+          else
+            RBS::AST::Members::AttrAccessor.new(
+              name: name,
+              type: type&.type || Types::Bases::Any.new(location: nil),
+              ivar_name: false,
+              comment: nil,
+              kind: :instance,
+              annotations: [],
+              visibility: nil,
+              location: nil
+            )
+          end
+        end
+
+        new = RBS::AST::Members::MethodDefinition.new(
+          name: :new,
+          kind: :singleton,
+          overloads: [],
+          annotations: [],
+          location: nil,
+          comment: nil,
+          overloading: false,
+          visibility: nil
+        )
+
+        if decl.positional_init?
+          attr_params = decl.each_attribute.map do |name, attr|
+            RBS::Types::Function::Param.new(
+              type: attr&.type || Types::Bases::Any.new(location: nil),
+              name: name,
+              location: nil
+            )
+          end
+
+          method_type = Types::Function.empty(Types::Bases::Instance.new(location: nil))
+          if decl.required_new_args?
+            method_type = method_type.update(required_positionals: attr_params)
+          else
+            method_type = method_type.update(optional_positionals: attr_params)
+          end
+
+          new.overloads <<
+            RBS::AST::Members::MethodDefinition::Overload.new(
+              method_type: RBS::MethodType.new(type_params: [], type: method_type, block: nil, location: nil),
+              annotations: []
+            )
+        end
+
+        if decl.keyword_init?
+          attr_keywords = decl.each_attribute.map do |name, attr|
+            [
+              name,
+              RBS::Types::Function::Param.new(
+                type: attr&.type || Types::Bases::Any.new(location: nil),
+                name: nil,
+                location: nil
+              )
+            ]
+          end.to_h #: Hash[Symbol, RBS::Types::Function::Param]
+
+          method_type = Types::Function.empty(Types::Bases::Instance.new(location: nil))
+          if decl.required_new_args?
+            method_type = method_type.update(required_keywords: attr_keywords)
+          else
+            method_type = method_type.update(optional_keywords: attr_keywords)
+          end
+
+          new.overloads <<
+            RBS::AST::Members::MethodDefinition::Overload.new(
+              method_type: RBS::MethodType.new(type_params: [], type: method_type, block: nil, location: nil),
+              annotations: []
+            )
+        end
+
+        rbs << RBS::AST::Declarations::Class.new(
+          name: decl.constant_name,
+          type_params: [],
+          members: [*attributes, new],
+          super_class: RBS::AST::Declarations::Class::Super.new(
+            name: RBS::TypeName.new(name: :Struct, namespace: RBS::Namespace.empty),
+            args: [RBS::Types::Bases::Any.new(location: nil)],
+            location: nil
+          ),
+          annotations: decl.class_annotations,
+          location: nil,
+          comment: comment
+        )
+      end
+
       # @rbs decl: AST::Declarations::SingletonClassDecl
       # @rbs rbs: _Content
       # @rbs return: void
@@ -221,6 +421,7 @@ module RBS
             return
           end
 
+          visibility = member.visibility || decl&.visibility(member)
           rbs << RBS::AST::Members::MethodDefinition.new(
             name: member.method_name,
             kind: kind,
@@ -229,7 +430,7 @@ module RBS
             location: nil,
             comment: comment,
             overloading: member.overloading?,
-            visibility: member.visibility
+            visibility: visibility
           )
         when AST::Members::RubyAlias
           if member.comments
@@ -253,9 +454,9 @@ module RBS
             rbs.concat m
           end
         when AST::Members::RubyPrivate
-          rbs << RBS::AST::Members::Private.new(location: nil)
+          rbs << RBS::AST::Members::Private.new(location: nil) unless decl
         when AST::Members::RubyPublic
-          rbs << RBS::AST::Members::Public.new(location: nil)
+          rbs << RBS::AST::Members::Public.new(location: nil) unless decl
         when AST::Members::RBSIvar
           if m = member.rbs
             rbs << m

data/rbs_collection.lock.yaml

@@ -42,11 +42,11 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 4bf1c9687fc24cfbb30f4759653308c816f3a69f
+    revision: 03121e6bbf2340e3b179edcc351deac45476f4d0
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rbs
-  version: 3.5.1
+  version: 3.5.3
   source:
     type: rubygems
 - name: rdoc

data/sig/generated/rbs/inline/ast/annotations.rbs

@@ -157,6 +157,8 @@ module RBS
 
           # @rbs override
           def initialize: ...
+
+          def annotations: () -> Array[RBS::AST::Annotation]
         end
 
         # `# @rbs skip`

data/sig/generated/rbs/inline/ast/declarations.rbs

@@ -8,9 +8,12 @@ module RBS
           # @rbs node: Prism::Node
           # @rbs return: TypeName?
           def type_name: (Prism::Node node) -> TypeName?
+
+          # @rbs (Prism::Node) -> Prism::Node?
+          def value_node: (Prism::Node) -> Prism::Node?
         end
 
-        type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl | BlockDecl
+        type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl | BlockDecl | DataAssignDecl | StructAssignDecl
 
         interface _WithComments
           def comments: () -> AnnotationParser::ParsingResult?
@@ -112,6 +115,8 @@ module RBS
         end
 
         class SingletonClassDecl < ModuleOrClass[Prism::SingletonClassNode]
+          # @rbs (AST::Members::RubyDef) -> (:private | nil)
+          def visibility: (AST::Members::RubyDef) -> (:private | nil)
         end
 
         class BlockDecl < Base
@@ -129,6 +134,110 @@ module RBS
 
           def module_class_annotation: () -> (Annotations::ModuleDecl | Annotations::ClassDecl | nil)
         end
+
+        # @rbs module-self _WithTypeDecls
+        module DataStructUtil : _WithTypeDecls
+          interface _WithTypeDecls
+            def type_decls: () -> Hash[Integer, Annotations::TypeAssertion]
+
+            def each_attribute_argument: () { (Prism::Node) -> void } -> void
+
+            def comments: %a{pure} () -> AnnotationParser::ParsingResult?
+          end
+
+          # @rbs %a{pure}
+          # @rbs () { ([Symbol, Annotations::TypeAssertion?]) -> void } -> void
+          #    | () -> Enumerator[[Symbol, Annotations::TypeAssertion?], void]
+          %a{pure}
+          def each_attribute: () { ([ Symbol, Annotations::TypeAssertion? ]) -> void } -> void
+                            | () -> Enumerator[[ Symbol, Annotations::TypeAssertion? ], void]
+
+          def class_annotations: () -> Array[RBS::AST::Annotation]
+        end
+
+        class DataAssignDecl < Base
+          extend ConstantUtil
+
+          include DataStructUtil
+
+          attr_reader node: Prism::ConstantWriteNode
+
+          attr_reader comments: AnnotationParser::ParsingResult?
+
+          attr_reader type_decls: Hash[Integer, Annotations::TypeAssertion]
+
+          attr_reader data_define_node: Prism::CallNode
+
+          # @rbs (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+          def initialize: (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+
+          def start_line: () -> Integer
+
+          # @rbs %a{pure}
+          # @rbs () -> TypeName?
+          %a{pure}
+          def constant_name: () -> TypeName?
+
+          # @rbs (Prism::ConstantWriteNode) -> Prism::CallNode?
+          def self.data_define?: (Prism::ConstantWriteNode) -> Prism::CallNode?
+
+          # @rbs () { (Prism::Node) -> void } -> void
+          def each_attribute_argument: () { (Prism::Node) -> void } -> void
+        end
+
+        class StructAssignDecl < Base
+          extend ConstantUtil
+
+          include DataStructUtil
+
+          attr_reader node: Prism::ConstantWriteNode
+
+          attr_reader comments: AnnotationParser::ParsingResult?
+
+          attr_reader type_decls: Hash[Integer, Annotations::TypeAssertion]
+
+          attr_reader struct_new_node: Prism::CallNode
+
+          # @rbs (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+          def initialize: (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+
+          def start_line: () -> Integer
+
+          # @rbs %a{pure}
+          # @rbs () -> TypeName?
+          %a{pure}
+          def constant_name: () -> TypeName?
+
+          # @rbs () { (Prism::Node) -> void } -> void
+          def each_attribute_argument: () { (Prism::Node) -> void } -> void
+
+          # @rbs (Prism::ConstantWriteNode) -> Prism::CallNode?
+          def self.struct_new?: (Prism::ConstantWriteNode) -> Prism::CallNode?
+
+          # @rbs %a{pure}
+          %a{pure}
+          def keyword_init?: () -> bool
+
+          # @rbs %a{pure}
+          %a{pure}
+          def positional_init?: () -> bool
+
+          # Returns `true` is annotation is given to make all attributes *readonly*
+          #
+          # Add `# @rbs %a{rbs-inline:readonly-attributes=true}` to the class to make all attributes `attr_reader`, instead of `attr_accessor`.
+          #
+          # @rbs %a{pure}
+          %a{pure}
+          def readonly_attributes?: () -> bool
+
+          # Returns `true` if annotation is given to make all `.new` arguments required
+          #
+          # Add `# @rbs %a{rbs-inline:new-args=required}` to the class to make all of the parameters required.
+          #
+          # @rbs %a{pure}
+          %a{pure}
+          def required_new_args?: () -> bool
+        end
       end
     end
   end

data/sig/generated/rbs/inline/writer.rbs

@@ -58,6 +58,14 @@ module RBS
       # @rbs return: void
       def translate_constant_decl: (AST::Declarations::ConstantDecl decl, _Content rbs) -> void
 
+      # @rbs decl: AST::Declarations::DataAssignDecl
+      # @rbs rbs: _Content
+      def translate_data_assign_decl: (AST::Declarations::DataAssignDecl decl, _Content rbs) -> void
+
+      # @rbs decl: AST::Declarations::StructAssignDecl
+      # @rbs rbs: _Content
+      def translate_struct_assign_decl: (AST::Declarations::StructAssignDecl decl, _Content rbs) -> void
+
       # @rbs decl: AST::Declarations::SingletonClassDecl
       # @rbs rbs: _Content
       # @rbs return: void

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs-inline
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -110,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: Inline RBS type declaration.