rbs-inline 0.3.0 → 0.5.0

data/lib/rbs/inline/writer.rb

@@ -1,20 +1,35 @@
+# rbs_inline: enabled
+
 module RBS
   module Inline
     class Writer
-      attr_reader :output
-      attr_reader :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
 
-      def initialize(buffer = +"")
+      # @rbs buffer: String
+      def initialize(buffer = +"") #: void
         @output = buffer
         @writer = RBS::Writer.new(out: StringIO.new(buffer))
       end
 
-      def self.write(uses, decls)
+      # @rbs uses: Array[AST::Annotations::Use]
+      # @rbs decls: Array[AST::Declarations::t]
+      # @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: String
+      # @rbs return: void
       def header(*lines)
         lines.each do |line|
           writer.out.puts("# " + line)
@@ -22,7 +37,12 @@ module RBS
         writer.out.puts
       end
 
-      def write(uses, decls)
+      # @rbs uses: Array[AST::Annotations::Use]
+      # @rbs decls: Array[AST::Declarations::t]
+      # @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,
@@ -30,48 +50,60 @@ 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
 
-      def translate_decl(decl)
+      # @rbs decl: AST::Declarations::t
+      # @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::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
 
-      def translate_class_decl(decl)
+      # @rbs decl: AST::Declarations::ClassDecl
+      # @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)
-              members.concat rbs_member
-            end
-          end
-
-          if member.is_a?(AST::Declarations::Base)
-            if rbs = translate_decl(member)
-              members << rbs
-            end
-          end
-        end
+        translate_members(decl.members, nil, members)
 
-        RBS::AST::Declarations::Class.new(
+        rbs << RBS::AST::Declarations::Class.new(
           name: decl.class_name,
           type_params: decl.type_params,
           members: members,
@@ -82,32 +114,46 @@ module RBS
         )
       end
 
-      def translate_module_decl(decl)
+      # @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
+            translate_decl(member, rbs)
+          end
+        end
+      end
+
+      # @rbs decl: AST::Declarations::ModuleDecl
+      # @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)
-              members.concat rbs_member
-            end
-          end
-
-          if 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,
@@ -118,14 +164,17 @@ module RBS
         )
       end
 
-      def translate_constant_decl(decl)
+      # @rbs decl: AST::Declarations::ConstantDecl
+      # @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,
@@ -133,78 +182,178 @@ module RBS
         )
       end
 
-      def translate_member(member)
+      # @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)
+            translate_member(member, decl, rbs)
+          end
+        end
+      end
+
+      # @rbs member: AST::Members::t
+      # @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
 
-          if member.override_annotation
-            return [
-              RBS::AST::Members::MethodDefinition.new(
-                name: member.method_name,
-                kind: member.method_kind,
-                overloads: [],
-                annotations: [],
-                location: nil,
-                comment: comment,
-                overloading: true,
-                visibility: member.visibility
-              )
-            ]
-          end
+          kind = method_kind(member, decl)
 
-          [
-            RBS::AST::Members::MethodDefinition.new(
+          if member.override_annotation
+            rbs << RBS::AST::Members::MethodDefinition.new(
               name: member.method_name,
-              kind: member.method_kind,
-              overloads: member.method_overloads,
-              annotations: member.method_annotations,
+              kind: kind,
+              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
+
+      private
+
+      # Returns the `kind` of the method definition
+      #
+      # ```rb
+      # def self.foo = ()    # :singleton
+      # class A
+      #   class << self
+      #     def bar = ()     # :singleton
+      #   end
+      # end
+      #
+      # def object.foo = ()  # Not supported (returns :instance)
+      # ```
+      #
+      # @rbs member: AST::Members::RubyDef
+      # @rbs decl: AST::Declarations::SingletonClassDecl?
+      # @rbs return: RBS::AST::Members::MethodDefinition::kind
+      def method_kind(member, decl)
+        return :singleton if decl
+
+        case member.node.receiver
+        when Prism::SelfNode
+          :singleton
+        else
+          :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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require_relative "inline/version"
 
@@ -7,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"
@@ -18,5 +20,7 @@ require "rbs/inline/writer"
 
 module RBS
   module Inline
+    # @rbs!
+    #   type token = [Symbol, String]
   end
 end

data/rbs_collection.lock.yaml

@@ -1,10 +1,6 @@
 ---
 path: ".gem_rbs_collection"
 gems:
-- name: abbrev
-  version: '0'
-  source:
-    type: stdlib
 - name: fileutils
   version: '0'
   source:
@@ -38,7 +34,7 @@ gems:
   source:
     type: stdlib
 - name: prism
-  version: 0.29.0
+  version: 0.30.0
   source:
     type: rubygems
 - name: rake
@@ -46,11 +42,11 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 7a105f52053ce1c708b605dfa9c1ab8473424036
+    revision: 4bf1c9687fc24cfbb30f4759653308c816f3a69f
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rbs
-  version: 3.5.0.pre.2
+  version: 3.5.1
   source:
     type: rubygems
 - name: rdoc

data/rbs_collection.yaml

@@ -15,3 +15,5 @@ path: .gem_rbs_collection
 
 gems:
   - name: optparse
+  - name: ffi
+    ignore: true