rbs 4.0.0.dev.4 → 4.0.0.dev.5

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

@@ -16,17 +16,67 @@ module RBS
         end
 
         class ClassDecl < Base
+          class SuperClass
+            attr_reader :type_name_location
+
+            attr_reader :operator_location
+
+            attr_reader :type_name
+
+            attr_reader :type_annotation
+
+            def initialize(type_name_location, operator_location, type_name, type_annotation)
+              @type_name_location = type_name_location
+              @operator_location = operator_location
+              @type_name = type_name
+              @type_annotation = type_annotation
+            end
+
+            def type_args
+              if type_annotation
+                type_annotation.type_args
+              else
+                []
+              end
+            end
+
+            def location
+              if type_annotation
+                Location.new(
+                  type_name_location.buffer,
+                  type_name_location.start_pos,
+                  type_annotation.location.end_pos
+                )
+              else
+                type_name_location
+              end
+            end
+
+            alias name type_name
+            alias args type_args
+
+            def type_fingerprint
+              [
+                type_name.to_s,
+                type_annotation&.type_fingerprint
+              ]
+            end
+          end
+
           attr_reader :class_name
 
           attr_reader :members
 
           attr_reader :node
 
-          def initialize(buffer, name, node)
+          attr_reader :super_class
+
+          def initialize(buffer, name, node, super_class)
             super(buffer)
             @class_name = name
             @node = node
             @members = []
+            @super_class = super_class
           end
 
           def each_decl(&block)
@@ -39,13 +89,26 @@ module RBS
             end
           end
 
-          def super_class = nil
-
           def type_params = []
 
           def location
             rbs_location(node.location)
           end
+
+          def name_location
+            rbs_location(node.constant_path.location)
+          end
+
+          def type_fingerprint
+            result = [] #: Array[untyped]
+
+            result << "decls/class"
+            result << class_name.to_s
+            result << super_class&.type_fingerprint
+            result << members.map { _1.type_fingerprint }
+
+            result
+          end
         end
 
         class ModuleDecl < Base
@@ -79,6 +142,138 @@ module RBS
           def location
             rbs_location(node.location)
           end
+
+          def name_location
+            rbs_location(node.constant_path.location)
+          end
+
+          def type_fingerprint
+            result = [] #: Array[untyped]
+
+            result << "decls/module"
+            result << module_name.to_s
+            result << members.map { _1.type_fingerprint}
+
+            result
+          end
+        end
+
+        class ConstantDecl < Base
+          attr_reader :leading_comment
+          attr_reader :constant_name
+          attr_reader :node
+          attr_reader :type_annotation
+
+          def initialize(buffer, constant_name, node, leading_comment, type_annotation)
+            super(buffer)
+            @constant_name = constant_name
+            @node = node
+            @leading_comment = leading_comment
+            @type_annotation = type_annotation
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            case node
+            when Prism::ConstantWriteNode
+              rbs_location(node.name_loc)
+            when Prism::ConstantPathWriteNode
+              rbs_location(node.target.location)
+            end
+          end
+
+          def type
+            return type_annotation.type if type_annotation
+
+            case node.value
+            when Prism::IntegerNode
+              BuiltinNames::Integer.instance_type
+            when Prism::FloatNode
+              BuiltinNames::Float.instance_type
+            when Prism::StringNode
+              BuiltinNames::String.instance_type
+            when Prism::TrueNode, Prism::FalseNode
+              Types::Bases::Bool.new(location: nil)
+            when Prism::SymbolNode
+              BuiltinNames::Symbol.instance_type
+            when Prism::NilNode
+              Types::Bases::Nil.new(location: nil)
+            else
+              Types::Bases::Any.new(location: nil)
+            end
+          end
+
+          def comment
+            leading_comment&.as_comment
+          end
+
+          def type_fingerprint
+            [
+              "decls/constant",
+              constant_name.to_s,
+              type.to_s,
+              leading_comment&.as_comment&.string
+            ]
+          end
+        end
+
+        class ClassModuleAliasDecl < Base
+          attr_reader :node
+          attr_reader :leading_comment
+          attr_reader :new_name
+          attr_reader :infered_old_name
+          attr_reader :annotation
+
+          def initialize(buffer, node, new_name, infered_old_name, leading_comment, annotation)
+            super(buffer)
+            @node = node
+            @new_name = new_name
+            @infered_old_name = infered_old_name
+            @leading_comment = leading_comment
+            @annotation = annotation
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            case node
+            when Prism::ConstantWriteNode
+              rbs_location(node.name_loc)
+            when Prism::ConstantPathWriteNode
+              rbs_location(node.target.location)
+            end
+          end
+
+          def old_name
+            # Return explicit type name from annotation if provided, otherwise use inferred name
+            case
+            when annotation.type_name
+              annotation.type_name
+            when infered_old_name
+              infered_old_name
+            else
+              raise "No old name available"
+            end
+          end
+
+          def comment
+            leading_comment&.as_comment
+          end
+
+          def type_fingerprint
+            [
+              "decls/class_module_alias",
+              annotation.type_fingerprint,
+              new_name.to_s,
+              old_name.to_s,
+              leading_comment&.as_comment&.string
+            ]
+          end
         end
       end
     end

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

@@ -15,6 +15,10 @@ module RBS
               rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
                 nil
               end
+            when Prism::ConstantWriteNode
+              TypeName.new(name: node.name, namespace: Namespace.empty)
+            when Prism::ConstantPathWriteNode
+              constant_as_type_name(node.target)
             end
           end
         end

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

@@ -28,6 +28,10 @@ module RBS
               end #: self
             end
 
+            def type_fingerprint
+              return_type_annotation&.type_fingerprint
+            end
+
             def method_type
               return_type =
                 case return_type_annotation
@@ -175,6 +179,17 @@ module RBS
               ]
             end
           end
+
+          def type_fingerprint
+            case type_annotations
+            when DocStyle
+              type_annotations.type_fingerprint
+            when Array
+              type_annotations.map(&:type_fingerprint)
+            when nil
+              nil
+            end
+          end
         end
 
         class DefMember < Base
@@ -183,12 +198,14 @@ module RBS
           attr_reader :name
           attr_reader :node
           attr_reader :method_type
+          attr_reader :leading_comment
 
-          def initialize(buffer, name, node, method_type)
+          def initialize(buffer, name, node, method_type, leading_comment)
             super(buffer)
             @name = name
             @node = node
             @method_type = method_type
+            @leading_comment = leading_comment
           end
 
           def location
@@ -206,6 +223,147 @@ module RBS
           def annotations
             []
           end
+
+          def name_location
+            rbs_location(node.name_loc)
+          end
+
+          def type_fingerprint
+            [
+              "members/def",
+              name.to_s,
+              method_type.type_fingerprint,
+              leading_comment&.as_comment&.string
+            ]
+          end
+        end
+
+        class MixinMember < Base
+          attr_reader :node
+          attr_reader :module_name
+          attr_reader :annotation
+
+          def initialize(buffer, node, module_name, annotation)
+            super(buffer)
+            @node = node
+            @module_name = module_name
+            @annotation = annotation
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            args = node.arguments or raise
+            first_arg = args.arguments.first or raise
+
+            rbs_location(first_arg.location)
+          end
+
+          def type_args
+            annotation&.type_args || []
+          end
+
+          def type_fingerprint
+            [
+              "members/mixin",
+              self.class.name,
+              module_name.to_s,
+              annotation&.type_fingerprint
+            ]
+          end
+        end
+
+        class IncludeMember < MixinMember
+        end
+
+        class ExtendMember < MixinMember
+        end
+
+        class PrependMember < MixinMember
+        end
+
+        class AttributeMember < Base
+          attr_reader :node
+          attr_reader :name_nodes
+          attr_reader :type_annotation
+          attr_reader :leading_comment
+
+          def initialize(buffer, node, name_nodes, leading_comment, type_annotation)
+            super(buffer)
+            @node = node
+            @name_nodes = name_nodes
+            @leading_comment = leading_comment
+            @type_annotation = type_annotation
+          end
+
+          def names
+            name_nodes.map do |node|
+              node.unescaped.to_sym
+            end
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_locations
+            name_nodes.map do |name_node|
+              rbs_location(name_node.location)
+            end
+          end
+
+          def type
+            type_annotation&.type
+          end
+
+          def type_fingerprint
+            [
+              "members/attribute",
+              self.class.name,
+              names.map(&:to_s),
+              type_annotation&.type_fingerprint,
+              leading_comment&.as_comment&.string
+            ]
+          end
+        end
+
+        class AttrReaderMember < AttributeMember
+        end
+
+        class AttrWriterMember < AttributeMember
+        end
+
+        class AttrAccessorMember < AttributeMember
+        end
+
+        class InstanceVariableMember < Base
+          attr_reader :annotation
+
+          def initialize(buffer, annotation)
+            super(buffer)
+            @annotation = annotation
+          end
+
+          def name
+            annotation.ivar_name
+          end
+
+          def type
+            annotation.type
+          end
+
+          def location
+            annotation.location
+          end
+
+          def type_fingerprint
+            [
+              "members/instance_variable",
+              annotation.type_fingerprint
+            ]
+          end
         end
       end
     end

data/lib/rbs/ast/type_param.rb

@@ -3,12 +3,13 @@
 module RBS
   module AST
     class TypeParam
-      attr_reader :name, :variance, :location, :upper_bound_type, :default_type
+      attr_reader :name, :variance, :location, :upper_bound_type, :lower_bound_type, :default_type
 
-      def initialize(name:, variance:, upper_bound:, location:, default_type: nil, unchecked: false)
+      def initialize(name:, variance:, upper_bound:, lower_bound:, location:, default_type: nil, unchecked: false)
         @name = name
         @variance = variance
         @upper_bound_type = upper_bound
+        @lower_bound_type = lower_bound
         @location = location
         @default_type = default_type
         @unchecked = unchecked
@@ -21,6 +22,13 @@ module RBS
         end
       end
 
+      def lower_bound
+        case lower_bound_type
+        when Types::ClassInstance, Types::ClassSingleton, Types::Interface
+          lower_bound_type
+        end
+      end
+
       def unchecked!(value = true)
         @unchecked = value ? true : false
         self
@@ -35,6 +43,7 @@ module RBS
           other.name == name &&
           other.variance == variance &&
           other.upper_bound_type == upper_bound_type &&
+          other.lower_bound_type == lower_bound_type &&
           other.default_type == default_type &&
           other.unchecked? == unchecked?
       end
@@ -42,7 +51,7 @@ module RBS
       alias eql? ==
 
       def hash
-        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ unchecked?.hash ^ default_type.hash
+        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ lower_bound_type.hash ^ unchecked?.hash ^ default_type.hash
       end
 
       def to_json(state = JSON::State.new)
@@ -52,6 +61,7 @@ module RBS
           unchecked: unchecked?,
           location: location,
           upper_bound: upper_bound_type,
+          lower_bound: lower_bound_type,
           default_type: default_type
         }.to_json(state)
       end
@@ -61,6 +71,10 @@ module RBS
           _upper_bound_type = yield(b)
         end
 
+        if b = lower_bound_type
+          _lower_bound_type = yield(b)
+        end
+
         if dt = default_type
           _default_type = yield(dt)
         end
@@ -69,6 +83,7 @@ module RBS
           name: name,
           variance: variance,
           upper_bound: _upper_bound_type,
+          lower_bound: _lower_bound_type,
           location: location,
           default_type: _default_type
         ).unchecked!(unchecked?)
@@ -108,6 +123,7 @@ module RBS
             name: new_name,
             variance: param.variance,
             upper_bound: param.upper_bound_type&.map_type {|type| type.sub(subst) },
+            lower_bound: param.lower_bound_type&.map_type {|type| type.sub(subst) },
             location: param.location,
             default_type: param.default_type&.map_type {|type| type.sub(subst) }
           ).unchecked!(param.unchecked?)
@@ -136,6 +152,10 @@ module RBS
           s << " < #{type}"
         end
 
+        if type = lower_bound_type
+          s << " > #{type}"
+        end
+
         if dt = default_type
           s << " = #{dt}"
         end
@@ -176,7 +196,7 @@ module RBS
       end
 
       def self.normalize_args(params, args)
-        app = application(params, args) or return []
+        app = application(params, args) or return args
 
         min_count = params.count { _1.default_type.nil? }
         unless min_count <= args.size && args.size <= params.size

data/lib/rbs/buffer.rb

@@ -29,19 +29,24 @@ module RBS
 
     def 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
+        if content.empty?
+          ranges = [0...0] #: Array[Range[Integer]]
+          lines = [""]
+        else
+          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
         end
 
         ranges
@@ -84,9 +89,9 @@ module RBS
 
     def rbs_location(location, loc2=nil)
       if loc2
-        Location.new(self, location.start_character_offset, loc2.end_character_offset)
+        Location.new(self.top_buffer, location.start_character_offset, loc2.end_character_offset)
       else
-        Location.new(self, location.start_character_offset, location.end_character_offset)
+        Location.new(self.top_buffer, location.start_character_offset, location.end_character_offset)
       end
     end
 

data/lib/rbs/cli/diff.rb

@@ -3,13 +3,14 @@
 module RBS
   class CLI
     class Diff
-      def initialize(argv:, library_options:, stdout: $stdout, stderr: $stderr)
-        @format = nil
+      def initialize(stdout: $stdout, stderr: $stderr)
         @stdout = stdout
         @stderr = stderr
+      end
 
-        # @type var type_name: String?
-        type_name = nil
+      def run(argv:, library_options:)
+        format = nil #: String?
+        type_name = nil #: String?
         library_options = library_options
         before_path = [] #: Array[String]
         after_path = [] #: Array[String]
@@ -32,7 +33,7 @@ module RBS
               # Confirmation of methods related to Time class added by including stdlib/time
               $ rbs diff --format diff --type-name Time --after stdlib/time
           HELP
-          o.on("--format NAME")    { |arg| @format = arg }
+          o.on("--format NAME")    { |arg| format = arg }
           o.on("--type-name NAME") { |arg| type_name = arg }
           o.on("--before DIR")     { |arg| before_path << arg }
           o.on("--after DIR")      { |arg| after_path << arg }
@@ -40,28 +41,28 @@ module RBS
         end
         opt.parse!(argv)
 
-        unless @format && type_name && ["markdown", "diff"].include?(@format)
+        unless format && type_name && ["markdown", "diff"].include?(format)
           @stderr.puts opt.banner
-          exit 1
+          return 1
         end
 
-        @diff = RBS::Diff.new(
+        diff = RBS::Diff.new(
           type_name: TypeName.parse(type_name).absolute!,
           library_options: library_options,
           after_path: after_path,
           before_path: before_path,
           detail: detail,
         )
-      end
 
-      def run
-        public_send("run_#{@format}")
+        public_send("run_#{format}", diff)
+
+        0
       end
 
-      def run_diff
+      def run_diff(diff)
         first = true
         io = RBS::CLI::ColoredIO.new(stdout: @stdout)
-        @diff.each_diff do |before, after|
+        diff.each_diff do |before, after|
           io.puts if !first
           io.puts_red   "- #{before}"
           io.puts_green "+ #{after}"
@@ -69,10 +70,10 @@ module RBS
         end
       end
 
-      def run_markdown
+      def run_markdown(diff)
         @stdout.puts "| before | after |"
         @stdout.puts "| --- | --- |"
-        @diff.each_diff do |before, after|
+        diff.each_diff do |before, after|
           before.gsub!("|", "\\|")
           after.gsub!("|", "\\|")
           @stdout.puts "| `#{before}` | `#{after}` |"