rbs-inline 0.4.0 → 0.6.0

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

@@ -3,7 +3,7 @@
 module RBS
   module Inline
     module AST
-      # CommentLines represents consecutive comments
+      # CommentLines represents consecutive comments, providing a mapping from locations in `#string` to a pair of a comment and its offset
       #
       # The comments construct one String.
       #
@@ -16,37 +16,34 @@ module RBS
       # And want to translate a location in the string into the location in comment1 and comment2.
       #
       class CommentLines
-        attr_reader :comments #:: Array[[Prism::Comment, Integer]]
+        attr_reader :comments #: Array[Prism::Comment]
 
         # @rbs comments: Array[Prism::Comment]
-        def initialize(comments)
-          offsets = comments.map do |comment|
-            comment.location.slice.index(/[^#\s]/) || 1
-          end
-          first_offset = offsets[0]
-
-          @comments = comments.map.with_index do |comment, index|
-            offset = offsets[index]
-            offset = first_offset if offset > first_offset
+        def initialize(comments) #: void
+          @comments = comments
+        end
 
-            [comment, offset]
-          end
+        def lines #: Array[String]
+          comments.map {|comment| comment.location.slice }
         end
 
-        def string #:: String
-          comments.map {|comment, offset| comment.location.slice[offset..] }.join("\n")
+        def string #: String
+          comments.map {|comment| comment.location.slice[1..] || "" }.join("\n")
         end
 
+        # Translates the cursor index of `#string` into the cursor index of a specific comment object
+        #
         # @rbs index: Integer
-        # @rbs returns [Prism::Comment, Integer]?
+        # @rbs return: [Prism::Comment, Integer]?
         def comment_location(index)
-          comments.each do |comment, offset|
+          comments.each do |comment|
             comment_length = comment.location.length
 
-            if index + offset <= comment_length
-              return [comment, index + offset]
+            if index + 1 <= comment_length
+              return [comment, index + 1]
             else
-              index = index - comment_length + offset - 1
+              index -= comment_length - 1
+              index -= 1 # newline
               return if index < 0
             end
           end

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

@@ -6,28 +6,40 @@ module RBS
       module Declarations
         module ConstantUtil
           # @rbs node: Prism::Node
-          # @rbs returns TypeName?
+          # @rbs return: TypeName?
           def type_name(node)
             case node
             when Prism::ConstantReadNode, Prism::ConstantPathNode
               TypeName(node.full_name)
             end
           end
-        end
 
-        # @rbs! type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl
+          # @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 | DataAssignDecl | StructAssignDecl
+        #
         #  interface _WithComments
         #    def comments: () -> AnnotationParser::ParsingResult?
         #  end
 
         # @rbs module-self _WithComments
         module Generics
-          # @rbs returns Array[RBS::AST::TypeParam]
+          # @rbs return: Array[RBS::AST::TypeParam]
           def type_params
             if comments = comments()
-              comments.annotations.filter_map do |annotation|
+              comments.each_annotation.filter_map do |annotation|
                 if annotation.is_a?(Annotations::Generic)
                   annotation.type_param
                 end
@@ -44,26 +56,26 @@ module RBS
         # @rbs generic NODE < Prism::Node
         class ModuleOrClass < Base
           # The node that represents the declaration
-          attr_reader :node #:: NODE
+          attr_reader :node #: NODE
 
           # Leading comment
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
+          attr_reader :comments #: AnnotationParser::ParsingResult?
 
           # Members included in the declaration
-          attr_reader :members #:: Array[Members::t | t]
+          attr_reader :members #: Array[Members::t | t]
 
           # @rbs node: NODE
           # @rbs comments: AnnotationParser::ParsingResult?
-          def initialize(node, comments) #:: void
+          def initialize(node, comments) #: void
             @node = node
             @comments = comments
             @members = []
           end
 
           # Type parameters for the declaration
-          def type_params #:: Array[RBS::AST::TypeParam]
+          def type_params #: Array[RBS::AST::TypeParam]
             if comments = comments()
-              comments.annotations.filter_map do |annotation|
+              comments.each_annotation.filter_map do |annotation|
                 if annotation.is_a?(Annotations::Generic)
                   annotation.type_param
                 end
@@ -73,7 +85,7 @@ module RBS
             end
           end
 
-          def start_line #:: Integer
+          def start_line #: Integer
             node.location.start_line
           end
         end
@@ -82,12 +94,12 @@ module RBS
           include ConstantUtil
 
           # Type application for super class
-          attr_reader :super_app #:: Annotations::Application?
+          attr_reader :super_app #: Annotations::Application?
 
           # @rbs node: Prism::ClassNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs super_app: Annotations::Application?
-          # @rbs returns void
+          # @rbs return: void
           def initialize(node, comments, super_app)
             super(node, comments)
 
@@ -95,14 +107,14 @@ module RBS
           end
 
           # @rbs %a{pure}
-          def class_name #:: TypeName?
+          def class_name #: TypeName?
             type_name(node.constant_path)
           end
 
           # @rbs %a{pure}
-          def super_class #:: RBS::AST::Declarations::Class::Super?
+          def super_class #: RBS::AST::Declarations::Class::Super?
             if comments
-              if inherits = comments.annotations.find {|a| a.is_a?(Annotations::Inherits) } #: Annotations::Inherits?
+              if inherits = comments.each_annotation.find {|a| a.is_a?(Annotations::Inherits) } #: Annotations::Inherits?
                 super_name = inherits.super_name
                 super_args = inherits.args
 
@@ -141,14 +153,14 @@ module RBS
           include ConstantUtil
 
           # @rbs %a{pure}
-          def module_name #:: TypeName?
+          def module_name #: TypeName?
             type_name(node.constant_path)
           end
 
           # @rbs %a{pure}
-          def module_selfs #:: Array[Annotations::ModuleSelf]
+          def module_selfs #: Array[Annotations::ModuleSelf]
             if comments
-              comments.annotations.filter_map do |ann|
+              comments.each_annotation.filter_map do |ann|
                 if ann.is_a?(AST::Annotations::ModuleSelf)
                   ann
                 end
@@ -162,21 +174,21 @@ module RBS
         class ConstantDecl < Base
           include ConstantUtil
 
-          attr_reader :node #:: Prism::ConstantWriteNode
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
-          attr_reader :assertion #:: Annotations::Assertion?
+          attr_reader :node #: Prism::ConstantWriteNode
+          attr_reader :comments #: AnnotationParser::ParsingResult?
+          attr_reader :assertion #: Annotations::TypeAssertion?
 
           # @rbs node: Prism::ConstantWriteNode
           # @rbs comments: AnnotationParser::ParsingResult?
-          # @rbs assertion: Annotations::Assertion?
-          def initialize(node, comments, assertion)
+          # @rbs assertion: Annotations::TypeAssertion?
+          def initialize(node, comments, assertion) #: void
             @node = node
             @comments = comments
             @assertion = assertion
           end
 
           # @rbs %a{pure}
-          # @rbs returns Types::t
+          # @rbs return: Types::t
           def type
             if assertion
               case assertion.type
@@ -218,18 +230,279 @@ module RBS
           end
 
           # @rbs %a{pure}
-          # @rbs returns TypeName?
+          # @rbs return: TypeName?
           def constant_name
             TypeName.new(name: node.name, namespace: Namespace.empty)
           end
 
-          def start_line #:: Integer
+          def start_line #: Integer
             node.location.start_line
           end
         end
 
         class SingletonClassDecl < ModuleOrClass #[Prism::SingletonClassNode]
         end
+
+        class BlockDecl < Base
+          attr_reader :node #: Prism::BlockNode
+
+          attr_reader :comments #: AnnotationParser::ParsingResult?
+
+          # Members included in the declaration
+          attr_reader :members #: Array[Members::t | t]
+
+          # @rbs (Prism::BlockNode, AnnotationParser::ParsingResult?) -> void
+          def initialize(node, comments)
+            @node = node
+            @members = []
+            @comments = comments
+          end
+
+          def start_line #: Integer
+            node.location.start_line
+          end
+
+          def module_class_annotation #: Annotations::ModuleDecl | Annotations::ClassDecl | nil
+            if comments
+              comments.each_annotation.each do |annotation|
+                if annotation.is_a?(Annotations::ModuleDecl)
+                  return annotation
+                end
+
+                if annotation.is_a?(Annotations::ClassDecl)
+                  return annotation
+                end
+              end
+
+              nil
+            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