rbs-inline 0.4.0 → 0.6.0

data/lib/rbs/inline/cli.rb

@@ -17,22 +17,22 @@ module RBS
       #
       #
       class PathCalculator
-        attr_reader :pwd #:: Pathname
+        attr_reader :pwd #: Pathname
 
-        attr_reader :base_paths #:: Array[Pathname]
+        attr_reader :base_paths #: Array[Pathname]
 
-        attr_reader :output_path #:: Pathname
+        attr_reader :output_path #: Pathname
 
         # @rbs pwd: Pathname
         # @rbs base_paths: Array[Pathname]
         # @rbs output_path: Pathname
-        def initialize(pwd, base_paths, output_path) #:: void
+        def initialize(pwd, base_paths, output_path) #: void
           @pwd = pwd
           @base_paths = base_paths
           @output_path = output_path
         end
 
-        #:: (Pathname) -> Pathname?
+        #: (Pathname) -> Pathname?
         def calculate(path)
           path = pwd + path if path.relative?
           path = path.cleanpath
@@ -49,18 +49,18 @@ module RBS
 
         # @rbs path: Pathname
         # @rbs prefix: Pathname
-        # @rbs returns bool
+        # @rbs return: bool
         def has_prefix?(path, prefix:)
           path.descend.include?(prefix)
         end
       end
 
-      attr_reader :stdout, :stderr #:: IO
-      attr_reader :logger #:: Logger
+      attr_reader :stdout, :stderr #: IO
+      attr_reader :logger #: Logger
 
       # @rbs stdout: IO
       # @rbs stderr: IO
-      def initialize(stdout: STDOUT, stderr: STDERR) #:: void
+      def initialize(stdout: STDOUT, stderr: STDERR) #: void
         @stdout = stdout
         @stderr = stderr
         @logger = Logger.new(stderr)
@@ -68,7 +68,7 @@ module RBS
       end
 
       # @rbs args: Array[String]
-      # @rbs returns Integer
+      # @rbs return: Integer
       def run(args)
         base_paths = [Pathname("lib"), Pathname("app")]
         output_path = nil #: Pathname?
@@ -139,10 +139,10 @@ module RBS
 
           logger.debug { "Parsing ruby file #{target}..." }
 
-          if (uses, decls = Parser.parse(Prism.parse_file(target.to_s), opt_in: opt_in))
+          if (uses, decls, rbs_decls = Parser.parse(Prism.parse_file(target.to_s), opt_in: opt_in))
             writer = Writer.new()
             writer.header("Generated from #{target.relative? ? target : target.relative_path_from(Pathname.pwd)} with RBS::Inline")
-            writer.write(uses, decls)
+            writer.write(uses, decls, rbs_decls)
 
             if output
               unless output.parent.directory?

data/lib/rbs/inline/node_utils.rb

@@ -4,7 +4,7 @@ module RBS
   module Inline
     module NodeUtils
       # @rbs node: Prism::Node
-      # @rbs returns TypeName?
+      # @rbs return: TypeName?
       def type_name(node)
         case node
         when Prism::ConstantReadNode

data/lib/rbs/inline/parser.rb

@@ -5,13 +5,18 @@
 module RBS
   module Inline
     class Parser < Prism::Visitor
+      # @rbs! type with_members = AST::Declarations::ModuleDecl
+      #                         | AST::Declarations::ClassDecl
+      #                         | AST::Declarations::SingletonClassDecl
+      #                         | AST::Declarations::BlockDecl
+
       # The top level declarations
       #
-      attr_reader :decls #:: Array[AST::Declarations::t]
+      attr_reader :decls #: Array[AST::Declarations::t]
 
       # The surrounding declarations
       #
-      attr_reader :surrounding_decls #:: Array[AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl]
+      attr_reader :surrounding_decls #: Array[with_members]
 
       # ParsingResult associated with the line number at the end
       #
@@ -23,24 +28,35 @@ module RBS
       # > [!IMPORTANT]
       # > The values will be removed during parsing.
       #
-      attr_reader :comments #:: Hash[Integer, AnnotationParser::ParsingResult]
+      attr_reader :comments #: Hash[Integer, AnnotationParser::ParsingResult]
 
       # The current visibility applied to single `def` node
       #
       # Assuming it's directly inside `private` or `public` calls.
       # `nil` when the `def` node is not inside `private` or `public` calls.
       #
-      attr_reader :current_visibility #:: RBS::AST::Members::visibility?
+      attr_reader :current_visibility #: RBS::AST::Members::visibility?
 
-      def initialize() #:: void
+      def initialize() #: void
         @decls = []
         @surrounding_decls = []
         @comments = {}
       end
 
+      # Parses the given Prism result to a three tuple
+      #
+      # Returns a three tuple of:
+      #
+      # 1. An array of `use` directives
+      # 2. An array of declarations
+      # 3. An array of RBS declarations given as `@rbs!` annotation at top-level
+      #
+      # Note that only RBS declarations are allowed in the top-level `@rbs!` annotations.
+      # RBS *members* are ignored in the array.
+      #
       # @rbs result: ParseResult
       # @rbs opt_in: bool -- `true` for *opt-out* mode, `false` for *opt-in* mode.
-      # @rbs returns [Array[AST::Annotations::Use], Array[AST::Declarations::t]]?
+      # @rbs return: [Array[AST::Annotations::Use], Array[AST::Declarations::t], Array[RBS::AST::Declarations::t]]?
       def self.parse(result, opt_in:)
         instance = Parser.new()
 
@@ -61,7 +77,7 @@ module RBS
 
         uses = [] #: Array[AST::Annotations::Use]
         annots.each do |annot|
-          annot.annotations.each do |annotation|
+          annot.each_annotation do |annotation|
             if annotation.is_a?(AST::Annotations::Use)
               uses << annotation
             end
@@ -70,24 +86,44 @@ module RBS
 
         instance.visit(result.value)
 
+        rbs_embeddeds = [] #: Array[AST::Members::RBSEmbedded]
+
+        instance.comments.each_value do |comment|
+          comment.each_annotation do |annotation|
+            if annotation.is_a?(AST::Annotations::Embedded)
+              rbs_embeddeds << AST::Members::RBSEmbedded.new(comment, annotation)
+            end
+          end
+        end
+
+        rbs_decls = rbs_embeddeds.flat_map do |embedded|
+          if (members = embedded.members).is_a?(Array)
+            members.select do |member|
+              member.is_a?(RBS::AST::Declarations::Base)
+            end
+          else
+            []
+          end #: Array[RBS::AST::Declarations::t]
+        end
+
         [
           uses,
-          instance.decls
+          instance.decls,
+          rbs_decls
         ]
       end
 
-      # @rbs returns AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | nil
+      # @rbs return: with_members?
       def current_class_module_decl
         surrounding_decls.last
       end
 
-      # @rbs returns AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl
+      # @rbs return: with_members
       def current_class_module_decl!
         current_class_module_decl or raise
       end
 
-      #:: (AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | AST::Declarations::SingletonClassDecl) { () -> void } -> void
-      #:: (AST::Declarations::ConstantDecl) -> void
+      #: (with_members) { () -> void } -> void
       def push_class_module_decl(decl)
         if current = current_class_module_decl
           current.members << decl
@@ -96,7 +132,7 @@ module RBS
         end
 
         if block_given?
-          surrounding_decls.push(_ = decl)
+          surrounding_decls.push(decl)
           begin
             yield
           ensure
@@ -114,11 +150,11 @@ module RBS
       # @rbs members: Array[AST::Members::t | AST::Declarations::t] --
       #   The destination.
       #   The method doesn't insert declarations, but have it to please type checker.
-      def load_inner_annotations(start_line, end_line, members) #:: void
+      def load_inner_annotations(start_line, end_line, members) #: void
         comments = inner_annotations(start_line, end_line)
 
         comments.each do |comment|
-          comment.annotations.each do |annotation|
+          comment.each_annotation do |annotation|
             case annotation
             when AST::Annotations::IvarType
               members << AST::Members::RBSIvar.new(comment, annotation)
@@ -133,51 +169,53 @@ module RBS
 
       # @rbs override
       def visit_class_node(node)
-        return if ignored_node?(node)
+        process_nesting_node(node) do
+          visit node.constant_path
+          visit node.superclass
 
-        visit node.constant_path
-        visit node.superclass
+          associated_comment = comments.delete(node.location.start_line - 1)
+          if node.superclass
+            app_comment = application_annotation(node.superclass)
+          end
 
-        associated_comment = comments.delete(node.location.start_line - 1)
-        if node.superclass
-          app_comment = application_annotation(node.superclass)
-        end
+          class_decl = AST::Declarations::ClassDecl.new(node, associated_comment, app_comment)
 
-        class_decl = AST::Declarations::ClassDecl.new(node, associated_comment, app_comment)
+          push_class_module_decl(class_decl) do
+            visit node.body
+          end
 
-        push_class_module_decl(class_decl) do
-          visit node.body
+          load_inner_annotations(node.location.start_line, node.location.end_line, class_decl.members)
         end
-
-        load_inner_annotations(node.location.start_line, node.location.end_line, class_decl.members)
       end
 
       # @rbs override
       def visit_singleton_class_node(node)
-        return if ignored_node?(node)
+        process_nesting_node(node) do
+          associated_comment = comments.delete(node.location.start_line - 1)
+          singleton_decl = AST::Declarations::SingletonClassDecl.new(node, associated_comment)
 
-        associated_comment = comments.delete(node.location.start_line - 1)
-        singleton_decl = AST::Declarations::SingletonClassDecl.new(node, associated_comment)
+          push_class_module_decl(singleton_decl) do
+            visit node.body
+          end
 
-        push_class_module_decl(singleton_decl) do
-          visit node.body
+          load_inner_annotations(node.location.start_line, node.location.end_line, singleton_decl.members)
         end
       end
 
       # @rbs override
       def visit_module_node(node)
-        return if ignored_node?(node)
+        process_nesting_node(node) do
+          visit node.constant_path
 
-        visit node.constant_path
+          associated_comment = comments.delete(node.location.start_line - 1)
 
-        associated_comment = comments.delete(node.location.start_line - 1)
+          module_decl = AST::Declarations::ModuleDecl.new(node, associated_comment)
+          push_class_module_decl(module_decl) do
+            visit node.body
+          end
 
-        module_decl = AST::Declarations::ModuleDecl.new(node, associated_comment)
-        push_class_module_decl(module_decl) do
-          visit node.body
+          load_inner_annotations(node.location.start_line, node.location.end_line, module_decl.members)
         end
-
-        load_inner_annotations(node.location.start_line, node.location.end_line, module_decl.members)
       end
 
       # Returns an array of annotations from comments that is located between start_line and end_line
@@ -191,7 +229,7 @@ module RBS
       #
       # @rbs start_line: Integer
       # @rbs end_line: Integer
-      def inner_annotations(start_line, end_line) #:: Array[AnnotationParser::ParsingResult]
+      def inner_annotations(start_line, end_line) #: Array[AnnotationParser::ParsingResult]
         annotations = comments.each_value.select do |annotation|
           range = annotation.line_range
           start_line < range.begin && range.end < end_line
@@ -204,25 +242,27 @@ module RBS
 
       # @rbs override
       def visit_def_node(node)
-        return if ignored_node?(node)
-        return unless current_class_module_decl
+        process_nesting_node(node) do
+          return unless current_class_module_decl
 
-        current_decl = current_class_module_decl!
+          current_decl = current_class_module_decl!
 
-        if node.location
-          associated_comment = comments.delete(node.location.start_line - 1)
-        end
+          if node.location
+            associated_comment = comments.delete(node.location.start_line - 1)
+          end
 
-        assertion = assertion_annotation(node.rparen_loc || node&.parameters&.location || node.name_loc)
+          assertion = assertion_annotation(node.rparen_loc || node&.parameters&.location || node.name_loc)
 
-        current_decl.members << AST::Members::RubyDef.new(node, associated_comment, current_visibility, assertion)
+          current_decl.members << AST::Members::RubyDef.new(node, associated_comment, current_visibility, assertion)
 
-        super
+          super
+        end
       end
 
       # @rbs override
       def visit_alias_method_node(node)
         return if ignored_node?(node)
+        return unless current_class_module_decl
 
         if node.location
           comment = comments.delete(node.location.start_line - 1)
@@ -256,9 +296,9 @@ module RBS
             end
             if assertion_comment && comment_line
               comments.delete(comment_line)
-              assertion = assertion_comment.annotations.find do |annotation|
-                annotation.is_a?(AST::Annotations::Assertion)
-              end #: AST::Annotations::Assertion?
+              assertion = assertion_comment.each_annotation.find do |annotation|
+                annotation.is_a?(AST::Annotations::TypeAssertion)
+              end #: AST::Annotations::TypeAssertion?
             end
 
             current_class_module_decl!.members << AST::Members::RubyAttr.new(node, comment, assertion)
@@ -296,8 +336,8 @@ module RBS
       end
 
       # @rbs new_visibility: RBS::AST::Members::visibility?
-      # @rbs block: ^() -> void
-      # @rbs returns void
+      # @rbs &block: () -> void
+      # @rbs return: void
       def push_visibility(new_visibility, &block)
         old_visibility = current_visibility
 
@@ -309,11 +349,21 @@ module RBS
         end
       end
 
+      # @rbs [A] (Node) { () -> A } -> A?
+      def process_nesting_node(node)
+        yield unless ignored_node?(node)
+      ensure
+        # Delete all inner annotations
+        inner_annotations(node.location.start_line, node.location.end_line)
+        comments.delete(node.location.start_line)
+        comments.delete(node.location.end_line)
+      end
+
       # @rbs node: Node
-      # @rbs returns bool
+      # @rbs return: bool
       def ignored_node?(node)
         if comment = comments.fetch(node.location.start_line - 1, nil)
-          comment.annotations.any? { _1.is_a?(AST::Annotations::Skip) }
+          comment.each_annotation.any? { _1.is_a?(AST::Annotations::Skip) }
         else
           false
         end
@@ -324,7 +374,7 @@ module RBS
       # The application annotation is removed from `comments`.
       #
       # @rbs node: Node
-      # @rbs returns AST::Annotations::Application?
+      # @rbs return: AST::Annotations::Application?
       def application_annotation(node)
         comment_line, app_comment = comments.find do |_, comment|
           comment.line_range.begin == node.location.end_line
@@ -332,18 +382,18 @@ module RBS
 
         if app_comment && comment_line
           comments.delete(comment_line)
-          app_comment.annotations.find do |annotation|
+          app_comment.each_annotation.find do |annotation|
             annotation.is_a?(AST::Annotations::Application)
           end #: AST::Annotations::Application?
         end
       end
 
-      # Fetch Assertion annotation which is associated to `node`
+      # Fetch TypeAssertion annotation which is associated to `node`
       #
       # The assertion annotation is removed from `comments`.
       #
       # @rbs node: Node | Location
-      # @rbs returns AST::Annotations::Assertion?
+      # @rbs return: AST::Annotations::TypeAssertion?
       def assertion_annotation(node)
         if node.is_a?(Prism::Location)
           location = node
@@ -356,9 +406,9 @@ module RBS
 
         if app_comment && comment_line
           comments.delete(comment_line)
-          app_comment.annotations.find do |annotation|
-            annotation.is_a?(AST::Annotations::Assertion)
-          end #: AST::Annotations::Assertion?
+          app_comment.each_annotation.find do |annotation|
+            annotation.is_a?(AST::Annotations::TypeAssertion)
+          end #: AST::Annotations::TypeAssertion?
         end
       end
 
@@ -367,10 +417,58 @@ 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)
-        push_class_module_decl(decl)
+        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
+        else
+          decls << decl
+        end
+      end
+
+      # @rbs override
+      def visit_block_node(node)
+        process_nesting_node(node) do
+          comment = comments.delete(node.location.start_line - 1)
+          block = AST::Declarations::BlockDecl.new(node, comment)
+
+          push_class_module_decl(block) do
+            super
+          end
+
+          load_inner_annotations(node.location.start_line, node.location.end_line, block.members)
+        end
       end
     end
   end

data/lib/rbs/inline/version.rb

@@ -2,6 +2,6 @@
 
 module RBS
   module Inline
-    VERSION = "0.4.0"
+    VERSION = "0.6.0"
   end
 end