rbs-inline 0.4.0 → 0.6.0

data/lib/rbs/inline/writer.rb

@@ -3,25 +3,33 @@
 module RBS
   module Inline
     class Writer
-      attr_reader :output #:: String
-      attr_reader :writer #:: RBS::Writer
+      # @rbs!
+      #   interface _Content
+      #     def <<: (RBS::AST::Declarations::t | RBS::AST::Members::t) -> void
+      #
+      #     def concat: (Array[RBS::AST::Declarations::t | RBS::AST::Members::t]) -> void
+      #   end
+
+      attr_reader :output #: String
+      attr_reader :writer #: RBS::Writer
 
       # @rbs buffer: String
-      def initialize(buffer = +"")
+      def initialize(buffer = +"") #: void
         @output = buffer
         @writer = RBS::Writer.new(out: StringIO.new(buffer))
       end
 
       # @rbs uses: Array[AST::Annotations::Use]
       # @rbs decls: Array[AST::Declarations::t]
-      def self.write(uses, decls)
+      # @rbs rbs_decls: Array[RBS::AST::Declarations::t]
+      def self.write(uses, decls, rbs_decls) #: void
         writer = Writer.new()
-        writer.write(uses, decls)
+        writer.write(uses, decls, rbs_decls)
         writer.output
       end
 
-      # @rbs lines: Array[String]
-      # @rbs returns void
+      # @rbs *lines: String
+      # @rbs return: void
       def header(*lines)
         lines.each do |line|
           writer.out.puts("# " + line)
@@ -31,8 +39,10 @@ module RBS
 
       # @rbs uses: Array[AST::Annotations::Use]
       # @rbs decls: Array[AST::Declarations::t]
-      # @rbs returns void
-      def write(uses, decls)
+      # @rbs rbs_decls: Array[RBS::AST::Declarations::t] --
+      #    Top level `rbs!` declarations
+      # @rbs return: void
+      def write(uses, decls, rbs_decls)
         use_dirs = uses.map do |use|
           RBS::AST::Directives::Use.new(
             clauses: use.clauses,
@@ -40,54 +50,64 @@ module RBS
           )
         end
 
-        rbs = decls.filter_map do |decl|
-          translate_decl(decl)
+        rbs = [] #: Array[RBS::AST::Declarations::t]
+
+        decls.each do |decl|
+          translate_decl(
+            decl,
+            rbs #: Array[RBS::AST::Declarations::t | RBS::AST::Members::t]
+          )
         end
 
-        writer.write(use_dirs + rbs)
+        rbs.concat(rbs_decls)
+
+        writer.write(
+          use_dirs + rbs
+        )
       end
 
       # @rbs decl: AST::Declarations::t
-      # @rbs returns RBS::AST::Declarations::t?
-      def translate_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_decl(decl, rbs)
         case decl
         when AST::Declarations::ClassDecl
-          translate_class_decl(decl)
+          translate_class_decl(decl, rbs)
         when AST::Declarations::ModuleDecl
-          translate_module_decl(decl)
+          translate_module_decl(decl, rbs)
         when AST::Declarations::ConstantDecl
-          translate_constant_decl(decl)
+          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
+            when AST::Annotations::ModuleDecl
+              translate_module_block_decl(decl, rbs)
+            when AST::Annotations::ClassDecl
+              translate_class_block_decl(decl, rbs)
+            end
+          end
         end
       end
 
       # @rbs decl: AST::Declarations::ClassDecl
-      # @rbs returns RBS::AST::Declarations::Class?
-      def translate_class_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_class_decl(decl, rbs)
         return unless decl.class_name
 
         if decl.comments
-          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
         end
 
         members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
 
-        decl.members.each do |member|
-          if member.is_a?(AST::Members::Base)
-            if rbs_member = translate_member(member, decl)
-              members.concat rbs_member
-            end
-          end
+        translate_members(decl.members, nil, members)
 
-          if member.is_a?(AST::Declarations::SingletonClassDecl)
-            members.concat translate_singleton_decl(member)
-          elsif member.is_a?(AST::Declarations::Base)
-            if rbs = translate_decl(member)
-              members << rbs
-            end
-          end
-        end
-
-        RBS::AST::Declarations::Class.new(
+        rbs << RBS::AST::Declarations::Class.new(
           name: decl.class_name,
           type_params: decl.type_params,
           members: members,
@@ -98,36 +118,46 @@ module RBS
         )
       end
 
+      # @rbs members: Array[AST::Declarations::t | AST::Members::t]
+      # @rbs decl: AST::Declarations::SingletonClassDecl?
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_members(members, decl, rbs)
+        members.each do |member|
+          case member
+          when AST::Members::Base
+            translate_member(member, decl, rbs)
+          when AST::Declarations::SingletonClassDecl
+            translate_singleton_decl(member, rbs)
+          when AST::Declarations::BlockDecl
+            if member.module_class_annotation
+              translate_decl(member, rbs)
+            else
+              translate_members(member.members, decl, rbs)
+            end
+          when AST::Declarations::ClassDecl, AST::Declarations::ModuleDecl, AST::Declarations::ConstantDecl, AST::Declarations::DataAssignDecl, AST::Declarations::StructAssignDecl
+            translate_decl(member, rbs)
+          end
+        end
+      end
+
       # @rbs decl: AST::Declarations::ModuleDecl
-      # @rbs returns RBS::AST::Declarations::Module?
-      def translate_module_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_module_decl(decl, rbs)
         return unless decl.module_name
 
         if decl.comments
-          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
         end
 
         members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
 
-        decl.members.each do |member|
-          if member.is_a?(AST::Members::Base)
-            if rbs_member = translate_member(member, decl)
-              members.concat rbs_member
-            end
-          end
-
-          if member.is_a?(AST::Declarations::SingletonClassDecl)
-            members.concat translate_singleton_decl(member)
-          elsif member.is_a?(AST::Declarations::Base)
-            if rbs = translate_decl(member)
-              members << rbs
-            end
-          end
-        end
+        translate_members(decl.members, nil, members)
 
         self_types = decl.module_selfs.map { _1.constraint }.compact
 
-        RBS::AST::Declarations::Module.new(
+        rbs << RBS::AST::Declarations::Module.new(
           name: decl.module_name,
           type_params: decl.type_params,
           members: members,
@@ -139,15 +169,16 @@ module RBS
       end
 
       # @rbs decl: AST::Declarations::ConstantDecl
-      # @rbs returns RBS::AST::Declarations::Constant?
-      def translate_constant_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_constant_decl(decl, rbs)
         return unless decl.constant_name
 
         if decl.comments
-          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
         end
 
-        RBS::AST::Declarations::Constant.new(
+        rbs << RBS::AST::Declarations::Constant.new(
           name: decl.constant_name,
           type: decl.type,
           comment: comment,
@@ -155,96 +186,284 @@ module RBS
         )
       end
 
-      # @rbs decl: AST::Declarations::SingletonClassDecl
-      # @rbs returns Array[RBS::AST::Members::t]
-      def translate_singleton_decl(decl)
-        members = []
+      # @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
+      def translate_singleton_decl(decl, rbs)
         decl.members.each do |member|
           if member.is_a?(AST::Members::Base)
-            if rbs_member = translate_member(member, decl)
-              members.concat rbs_member
-            end
+            translate_member(member, decl, rbs)
           end
         end
-
-        members
       end
 
       # @rbs member: AST::Members::t
-      # @rbs decl: AST::Declarations::ClassDecl | AST::Declarations::ModuleDecl | AST::Declarations::SingletonClassDecl
-      # @rbs returns Array[RBS::AST::Members::t | RBS::AST::Declarations::t]?
-      def translate_member(member, decl)
+      # @rbs decl: AST::Declarations::SingletonClassDecl? --
+      #   The surrouding singleton class definition
+      # @rbs rbs: _Content
+      # @rbs return void
+      def translate_member(member, decl, rbs)
         case member
         when AST::Members::RubyDef
           if member.comments
-            comment = RBS::AST::Comment.new(string: member.comments.content, location: nil)
+            comment = RBS::AST::Comment.new(string: member.comments.content(trim: true), location: nil)
           end
 
           kind = method_kind(member, decl)
 
           if member.override_annotation
-            return [
-              RBS::AST::Members::MethodDefinition.new(
-                name: member.method_name,
-                kind: kind,
-                overloads: [],
-                annotations: [],
-                location: nil,
-                comment: comment,
-                overloading: true,
-                visibility: member.visibility
-              )
-            ]
-          end
-
-          [
-            RBS::AST::Members::MethodDefinition.new(
+            rbs << RBS::AST::Members::MethodDefinition.new(
               name: member.method_name,
               kind: kind,
-              overloads: member.method_overloads,
-              annotations: member.method_annotations,
+              overloads: [],
+              annotations: [],
               location: nil,
               comment: comment,
-              overloading: false,
+              overloading: true,
               visibility: member.visibility
             )
-          ]
+            return
+          end
+
+          rbs << RBS::AST::Members::MethodDefinition.new(
+            name: member.method_name,
+            kind: kind,
+            overloads: member.method_overloads,
+            annotations: member.method_annotations,
+            location: nil,
+            comment: comment,
+            overloading: member.overloading?,
+            visibility: member.visibility
+          )
         when AST::Members::RubyAlias
           if member.comments
-            comment = RBS::AST::Comment.new(string: member.comments.content, location: nil)
+            comment = RBS::AST::Comment.new(string: member.comments.content(trim: true), location: nil)
           end
 
-          [
-            RBS::AST::Members::Alias.new(
-              new_name: member.new_name,
-              old_name: member.old_name,
-              kind: :instance,
-              annotations: [],
-              location: nil,
-              comment: comment
-            )
-          ]
+          rbs << RBS::AST::Members::Alias.new(
+            new_name: member.new_name,
+            old_name: member.old_name,
+            kind: :instance,
+            annotations: [],
+            location: nil,
+            comment: comment
+          )
         when AST::Members::RubyMixin
-          [member.rbs].compact
+          if m = member.rbs
+            rbs << m
+          end
         when AST::Members::RubyAttr
-          member.rbs
+          if m = member.rbs
+            rbs.concat m
+          end
         when AST::Members::RubyPrivate
-          [
-            RBS::AST::Members::Private.new(location: nil)
-          ]
+          rbs << RBS::AST::Members::Private.new(location: nil)
         when AST::Members::RubyPublic
-          [
-            RBS::AST::Members::Public.new(location: nil)
-          ]
+          rbs << RBS::AST::Members::Public.new(location: nil)
         when AST::Members::RBSIvar
-          [
-            member.rbs
-          ].compact
+          if m = member.rbs
+            rbs << m
+          end
         when AST::Members::RBSEmbedded
           case members = member.members
           when Array
-            members
+            rbs.concat members
           end
         end
       end
@@ -265,10 +484,10 @@ module RBS
       # ```
       #
       # @rbs member: AST::Members::RubyDef
-      # @rbs decl: AST::Declarations::ClassDecl | AST::Declarations::ModuleDecl | AST::Declarations::SingletonClassDecl
-      # @rbs returns RBS::AST::Members::MethodDefinition::kind
+      # @rbs decl: AST::Declarations::SingletonClassDecl?
+      # @rbs return: RBS::AST::Members::MethodDefinition::kind
       def method_kind(member, decl)
-        return :singleton if decl.is_a?(AST::Declarations::SingletonClassDecl)
+        return :singleton if decl
 
         case member.node.receiver
         when Prism::SelfNode
@@ -277,6 +496,64 @@ module RBS
           :instance
         end
       end
+
+      # @rbs block: AST::Declarations::BlockDecl
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_module_block_decl(block, rbs)
+        annotation = block.module_class_annotation
+        annotation.is_a?(AST::Annotations::ModuleDecl) or raise
+
+        return unless annotation.name
+
+        if block.comments
+          comment = RBS::AST::Comment.new(string: block.comments.content(trim: true), location: nil)
+        end
+
+        members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
+
+        translate_members(block.members, nil, members)
+
+        self_types = annotation.self_types
+
+        rbs << RBS::AST::Declarations::Module.new(
+          name: annotation.name,
+          type_params: annotation.type_params,
+          members: members,
+          self_types: self_types,
+          annotations: [],
+          location: nil,
+          comment: comment
+        )
+      end
+
+      # @rbs block: AST::Declarations::BlockDecl
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_class_block_decl(block, rbs)
+        annotation = block.module_class_annotation
+        annotation.is_a?(AST::Annotations::ClassDecl) or raise
+
+        return unless annotation.name
+
+        if block.comments
+          comment = RBS::AST::Comment.new(string: block.comments.content(trim: true), location: nil)
+        end
+
+        members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
+
+        translate_members(block.members, nil, members)
+
+        rbs << RBS::AST::Declarations::Class.new(
+          name: annotation.name,
+          type_params: annotation.type_params,
+          members: members,
+          super_class: annotation.super_class,
+          annotations: [],
+          location: nil,
+          comment: comment
+        )
+      end
     end
   end
 end

data/lib/rbs/inline.rb

@@ -8,6 +8,7 @@ require "strscan"
 require "rbs"
 
 require "rbs/inline/node_utils"
+require "rbs/inline/annotation_parser/tokenizer"
 require "rbs/inline/annotation_parser"
 require "rbs/inline/ast/annotations"
 require "rbs/inline/ast/comment_lines"

data/rbs_collection.lock.yaml

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