rbs 3.9.2 → 4.0.0.dev.1

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Declarations
+        class Base
+          attr_reader :buffer
+
+          include Helpers::ConstantHelper
+          include Helpers::LocationHelper
+
+          def initialize(buffer)
+            @buffer = buffer
+          end
+        end
+
+        class ClassDecl < Base
+          attr_reader :class_name
+
+          attr_reader :members
+
+          attr_reader :node
+
+          def initialize(buffer, name, node)
+            super(buffer)
+            @class_name = name
+            @node = node
+            @members = []
+          end
+
+          def each_decl(&block)
+            return enum_for(:each_decl) unless block
+
+            @members.each do |member|
+              if member.is_a?(Base)
+                yield member
+              end
+            end
+          end
+
+          def super_class = nil
+
+          def type_params = []
+
+          def location
+            rbs_location(node.location)
+          end
+        end
+
+        class ModuleDecl < Base
+          attr_reader :module_name
+
+          attr_reader :members
+
+          attr_reader :node
+
+          def initialize(buffer, name, node)
+            super(buffer)
+            @module_name = name
+            @node = node
+            @members = []
+          end
+
+          def each_decl(&block)
+            return enum_for(:each_decl) unless block
+
+            @members.each do |member|
+              if member.is_a?(Base)
+                yield member
+              end
+            end
+          end
+
+          def type_params = []
+
+          def self_types = []
+
+          def location
+            rbs_location(node.location)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/ruby/helpers/constant_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module ConstantHelper
+          module_function
+
+          def constant_as_type_name(node)
+            case node
+            when Prism::ConstantPathNode, Prism::ConstantReadNode
+              begin
+                TypeName.parse(node.full_name)
+              rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/ruby/helpers/location_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module LocationHelper
+          def rbs_location(location)
+            Location.new(buffer, location.start_character_offset, location.end_character_offset)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Members
+        class Base
+          attr_reader :buffer
+
+          def initialize(buffer)
+            @buffer = buffer
+          end
+
+          include Helpers::LocationHelper
+        end
+
+        class MethodTypeAnnotation
+          class DocStyle
+            attr_accessor :return_type_annotation
+
+            def initialize
+              @return_type_annotation = nil
+            end
+
+            def map_type_name(&block)
+              DocStyle.new.tap do |new|
+                new.return_type_annotation = return_type_annotation&.map_type_name(&block)
+              end #: self
+            end
+
+            def method_type
+              return_type =
+                case return_type_annotation
+                when Annotations::NodeTypeAssertion
+                  return_type_annotation.type
+                when Annotations::ReturnTypeAnnotation
+                  return_type_annotation.return_type
+                else
+                  Types::Bases::Any.new(location: nil)
+                end
+
+              type = Types::Function.new(
+                required_positionals: [],
+                optional_positionals: [],
+                rest_positionals: nil,
+                trailing_positionals: [],
+                required_keywords: {},
+                optional_keywords: {},
+                rest_keywords: nil,
+                return_type: return_type
+              )
+
+              MethodType.new(
+                type_params: [],
+                type: type,
+                block: nil,
+                location: nil
+              )
+            end
+          end
+
+          attr_reader :type_annotations
+
+          def initialize(type_annotations:)
+            @type_annotations = type_annotations
+          end
+
+          def map_type_name(&block)
+            case type_annotations
+            when Array
+              updated_annots = type_annotations.map do |annotation|
+                annotation.map_type_name(&block)
+              end
+            when DocStyle
+              updated_annots = type_annotations.map_type_name(&block)
+            end
+
+            MethodTypeAnnotation.new(type_annotations: updated_annots) #: self
+          end
+
+          def self.build(leading_block, trailing_block, variables)
+            unused_annotations = [] #: Array[Annotations::leading_annotation | CommentBlock::AnnotationSyntaxError]
+            unused_trailing_annotation = nil #: Annotations::trailing_annotation | CommentBlock::AnnotationSyntaxError | nil
+
+            type_annotations = nil #: type_annotations
+
+            if trailing_block
+              case annotation = trailing_block.trailing_annotation(variables)
+              when Annotations::NodeTypeAssertion
+                type_annotations = DocStyle.new()
+                type_annotations.return_type_annotation = annotation
+              else
+                unused_trailing_annotation = annotation
+              end
+            end
+
+            if leading_block
+              leading_block.each_paragraph(variables) do |paragraph|
+                next if paragraph.is_a?(Location)
+
+                if paragraph.is_a?(CommentBlock::AnnotationSyntaxError)
+                  unused_annotations << paragraph
+                  next
+                end
+
+                case paragraph
+                when Annotations::MethodTypesAnnotation, Annotations::ColonMethodTypeAnnotation
+                  type_annotations = [] unless type_annotations
+                  if type_annotations.is_a?(Array)
+                    type_annotations << paragraph
+                    next
+                  end
+                when Annotations::ReturnTypeAnnotation
+                  unless type_annotations
+                    type_annotations = DocStyle.new()
+                  end
+
+                  if type_annotations.is_a?(DocStyle)
+                    unless type_annotations.return_type_annotation
+                      type_annotations.return_type_annotation = paragraph
+                      next
+                    end
+                  end
+                end
+
+                unused_annotations << paragraph
+              end
+            end
+
+            [
+              MethodTypeAnnotation.new(
+                type_annotations: type_annotations
+              ),
+              unused_annotations,
+              unused_trailing_annotation
+            ]
+          end
+
+          def empty?
+            type_annotations.nil?
+          end
+
+          def overloads
+            case type_annotations
+            when DocStyle
+              method_type = type_annotations.method_type
+
+              [
+                AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type)
+              ]
+            when Array
+              type_annotations.flat_map do |annotation|
+                case annotation
+                when Annotations::ColonMethodTypeAnnotation
+                  [
+                    AST::Members::MethodDefinition::Overload.new(
+                      annotations: annotation.annotations,
+                      method_type: annotation.method_type
+                    )
+                  ]
+                when Annotations::MethodTypesAnnotation
+                  annotation.overloads
+                end
+              end
+            when nil
+              method_type = MethodType.new(
+                type_params: [],
+                type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
+                block: nil,
+                location: nil
+              )
+
+              [
+                AST::Members::MethodDefinition::Overload.new(method_type: method_type, annotations: [])
+              ]
+            end
+          end
+        end
+
+        class DefMember < Base
+          Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader :name
+          attr_reader :node
+          attr_reader :method_type
+
+          def initialize(buffer, name, node, method_type)
+            super(buffer)
+            @name = name
+            @node = node
+            @method_type = method_type
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def overloads
+            method_type.overloads
+          end
+
+          def overloading?
+            false
+          end
+
+          def annotations
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/buffer.rb

@@ -4,39 +4,53 @@ module RBS
   class Buffer
     attr_reader :name
     attr_reader :content
+    attr_reader :parent
 
-    def initialize(name:, content:)
-      @name = name
-      @content = content
+    def initialize(name: nil, content:, parent: nil)
+      case
+      when name && content
+        @name = name
+        @content = content
+        @parent = nil
+      when parent && content
+        @name = parent[0].name
+        @content = content
+        @parent = parent
+      end
     end
 
     def lines
-      @lines ||= content.lines
+      ranges.map { self.content[_1] || raise } #$ String
+    end
+
+    def line_count
+      ranges.size
     end
 
     def ranges
-      @ranges ||=
-        begin
-          @ranges = []
-          offset = 0
-          lines.each do |line|
-            size = line.size
-            range = offset...(offset+size)
-            @ranges << range
-            offset += size
-          end
-
-          if !content.end_with?("\n") && content.size > 0
-            @ranges[-1] = @ranges[-1].begin...(@ranges[-1].end+1)
-          end
-
-          @ranges
+      @ranges ||= begin
+        lines = content.lines
+        lines << "" if content.end_with?("\n")
+
+        ranges = [] #: Array[Range[Integer]]
+        offset = 0
+
+        lines.each do |line|
+          size0 = line.size
+          line = line.chomp
+          range = offset...(offset+line.size)
+          ranges << range
+
+          offset += size0
         end
+
+        ranges
+      end
     end
 
     def pos_to_loc(pos)
       index = ranges.bsearch_index do |range|
-        pos < range.end ? true : false
+        pos <= range.end ? true : false
       end
 
       if index
@@ -49,7 +63,7 @@ module RBS
     def loc_to_pos(loc)
       line, column = loc
 
-      if range = ranges[line - 1]
+      if range = ranges.fetch(line - 1, nil)
         range.begin + column
       else
         last_position
@@ -57,11 +71,77 @@ module RBS
     end
 
     def last_position
-      content.size
+      if ranges.empty?
+        0
+      else
+        ranges[-1].end
+      end
     end
 
     def inspect
-      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{lines.size} lines,>"
+      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{ranges.size} lines,>"
+    end
+
+    def rbs_location(location, loc2=nil)
+      if loc2
+        Location.new(self, location.start_character_offset, loc2.end_character_offset)
+      else
+        Location.new(self, location.start_character_offset, location.end_character_offset)
+      end
+    end
+
+    def sub_buffer(lines:)
+      buf = +""
+      lines.each_with_index do |range, index|
+        start_pos = range.begin
+        end_pos = range.end
+        slice = content[start_pos...end_pos] or raise
+        if slice.include?("\n")
+          raise "Line #{index + 1} cannot contain newline character."
+        end
+        buf << slice
+        buf << "\n"
+      end
+
+      buf.chomp!
+
+      Buffer.new(content: buf, parent: [self, lines])
+    end
+
+    def parent_buffer
+      if parent
+        parent[0]
+      end
+    end
+
+    def parent_position(position)
+      parent or raise "#parent_position is unavailable with buffer without parent"
+      return nil unless position <= last_position
+
+      line, column = pos_to_loc(position)
+      parent_range = parent[1][line - 1]
+      parent_range.begin + column
+    end
+
+    def absolute_position(position)
+      if parent_buffer
+        pos = parent_position(position) or return
+        parent_buffer.absolute_position(pos)
+      else
+        position
+      end
+    end
+
+    def top_buffer
+      if parent_buffer
+        parent_buffer.top_buffer
+      else
+        self
+      end
+    end
+
+    def detach
+      Buffer.new(name: name, content: content)
     end
   end
 end

data/lib/rbs/cli/validate.rb

@@ -109,8 +109,8 @@ EOU
 
           case entry
           when Environment::ClassEntry
-            entry.decls.each do |decl|
-              if super_class = decl.decl.super_class
+            entry.each_decl do |decl|
+              if super_class = decl.super_class
                 super_class.args.each do |arg|
                   void_type_context_validator(arg, true)
                   no_self_type_validator(arg)
@@ -120,8 +120,8 @@ EOU
               end
             end
           when Environment::ModuleEntry
-            entry.decls.each do |decl|
-              decl.decl.self_types.each do |self_type|
+            entry.each_decl do |decl|
+              decl.self_types.each do |self_type|
                 self_type.args.each do |arg|
                   void_type_context_validator(arg, true)
                   no_self_type_validator(arg)
@@ -143,7 +143,7 @@ EOU
             end
           end
 
-          d = entry.primary.decl
+          d = entry.primary_decl
 
           @validator.validate_type_params(
             d.type_params,
@@ -169,39 +169,44 @@ EOU
 
           TypeParamDefaultReferenceError.check!(d.type_params)
 
-          entry.decls.each do |d|
-            d.decl.each_member do |member|
-              case member
-              when AST::Members::MethodDefinition
-                @validator.validate_method_definition(member, type_name: name)
-                member.overloads.each do |ov|
-                  void_type_context_validator(ov.method_type)
-                end
-              when AST::Members::Attribute
-                void_type_context_validator(member.type)
-              when AST::Members::Mixin
-                member.args.each do |arg|
-                  no_self_type_validator(arg)
-                  unless arg.is_a?(Types::Bases::Void)
-                    void_type_context_validator(arg, true)
+          entry.each_decl do |decl|
+            case decl
+            when AST::Declarations::Base
+              decl.each_member do |member|
+                case member
+                when AST::Members::MethodDefinition
+                  @validator.validate_method_definition(member, type_name: name)
+                  member.overloads.each do |ov|
+                    void_type_context_validator(ov.method_type)
                   end
-                end
-                params =
-                  if member.name.class?
-                    module_decl = @env.normalized_module_entry(member.name) or raise
-                    module_decl.type_params
-                  else
-                    interface_decl = @env.interface_decls.fetch(member.name)
-                    interface_decl.decl.type_params
+                when AST::Members::Attribute
+                  void_type_context_validator(member.type)
+                when AST::Members::Mixin
+                  member.args.each do |arg|
+                    no_self_type_validator(arg)
+                    unless arg.is_a?(Types::Bases::Void)
+                      void_type_context_validator(arg, true)
+                    end
+                  end
+                  params =
+                    if member.name.class?
+                      module_decl = @env.normalized_module_entry(member.name) or raise
+                      module_decl.type_params
+                    else
+                      interface_decl = @env.interface_decls.fetch(member.name)
+                      interface_decl.decl.type_params
+                    end
+                  InvalidTypeApplicationError.check!(type_name: member.name, params: params, args: member.args, location: member.location)
+                when AST::Members::Var
+                  @validator.validate_variable(member)
+                  void_type_context_validator(member.type)
+                  if member.is_a?(AST::Members::ClassVariable)
+                    no_self_type_validator(member.type)
                   end
-                InvalidTypeApplicationError.check!(type_name: member.name, params: params, args: member.args, location: member.location)
-              when AST::Members::Var
-                @validator.validate_variable(member)
-                void_type_context_validator(member.type)
-                if member.is_a?(AST::Members::ClassVariable)
-                  no_self_type_validator(member.type)
                 end
               end
+            else
+              raise "Unknown declaration: #{decl.class}"
             end
           end
         rescue BaseError => error

data/lib/rbs/cli.rb

@@ -175,10 +175,9 @@ EOB
 
       env = Environment.from_loader(loader).resolve_type_names
 
-      decls = env.declarations.select do |decl|
-        loc = decl.location or raise
+      decls = env.sources.select do |source|
         # @type var name: String
-        name = loc.buffer.name
+        name = source.buffer.name.to_s
 
         patterns.empty? || patterns.any? do |pat|
           case pat
@@ -188,7 +187,7 @@ EOB
             name.end_with?(pat) || File.fnmatch(pat, name, File::FNM_EXTGLOB)
           end
         end
-      end
+      end.flat_map { _1.declarations }
 
       stdout.print JSON.generate(decls)
       stdout.flush
@@ -913,7 +912,7 @@ Options:
           Buffer.new(content: file_path.read, name: file_path)
         end
       end
-      bufs << Buffer.new(content: e_code, name: '-e') if e_code
+      bufs << Buffer.new(content: e_code, name: Pathname('-e')) if e_code
 
       bufs.each do |buf|
         RBS.logger.info "Parsing #{buf.name}..."

data/lib/rbs/definition.rb

@@ -62,7 +62,12 @@ module RBS
         end
 
         def comment
-          member.comment
+          case member
+          when AST::Members::Base
+            member.comment
+          when AST::Ruby::Members::Base
+            nil
+          end
         end
 
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)