rbs 4.0.0.dev.4 → 4.1.0.pre.2

data/lib/rbs/parser_aux.rb

@@ -5,14 +5,16 @@ require_relative "parser/token"
 
 module RBS
   class Parser
-    def self.parse_type(source, range: 0..., variables: [], require_eof: false)
+    def self.parse_type(source, range: nil, byte_range: 0..., variables: [], require_eof: false, void_allowed: true, self_allowed: true, classish_allowed: true)
       buf = buffer(source)
-      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
+      byte_range = byte_range(range, buf.content) if range
+      _parse_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof, void_allowed, self_allowed, classish_allowed)
     end
 
-    def self.parse_method_type(source, range: 0..., variables: [], require_eof: false)
+    def self.parse_method_type(source, range: nil, byte_range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
-      _parse_method_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
+      byte_range = byte_range(range, buf.content) if range
+      _parse_method_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof)
     end
 
     def self.parse_signature(source)
@@ -25,7 +27,8 @@ module RBS
         else
           0
         end
-      dirs, decls = _parse_signature(buf, start_pos, buf.last_position)
+      content = buf.content
+      dirs, decls = _parse_signature(buf, start_pos, content.bytesize)
 
       if resolved
         dirs = dirs.dup if dirs.frozen?
@@ -37,7 +40,7 @@ module RBS
 
     def self.parse_type_params(source, module_type_params: true)
       buf = buffer(source)
-      _parse_type_params(buf, 0, buf.last_position, module_type_params)
+      _parse_type_params(buf, 0, buf.content.bytesize, module_type_params)
     end
 
     def self.magic_comment(buf)
@@ -66,7 +69,7 @@ module RBS
 
     def self.lex(source)
       buf = buffer(source)
-      list = _lex(buf, buf.last_position)
+      list = _lex(buf, buf.content.bytesize)
       value = list.map do |type, location|
         Token.new(type: type, location: location)
       end
@@ -125,5 +128,15 @@ module RBS
       buf = buffer(source)
       _parse_inline_trailing_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
     end
+
+    def self.byte_range(char_range, content)
+      start_offset = char_range.begin
+      end_offset = char_range.end
+
+      start_prefix = content[0, start_offset] or raise if start_offset
+      end_prefix = content[0, end_offset] or raise if end_offset
+
+      start_prefix&.bytesize...end_prefix&.bytesize
+    end
   end
 end

data/lib/rbs/prototype/helpers.rb

@@ -5,6 +5,63 @@ module RBS
     module Helpers
       private
 
+      # Prism can't parse Ruby 3.2 code
+      if RUBY_VERSION >= "3.3"
+        def parse_comments(string, include_trailing:)
+          Prism.parse_comments(string, version: "current").yield_self do |prism_comments| # steep:ignore UnexpectedKeywordArgument
+            prism_comments.each_with_object({}) do |comment, hash| #$ Hash[Integer, AST::Comment]
+              # Skip EmbDoc comments
+              next unless comment.is_a?(Prism::InlineComment)
+              # skip like `module Foo # :nodoc:`
+              next if comment.trailing? && !include_trailing
+
+              line = comment.location.start_line
+              body = "#{comment.location.slice}\n"
+              body = body[2..-1] or raise
+              body = "\n" if body.empty?
+
+              comment = AST::Comment.new(string: body, location: nil)
+              if prev_comment = hash.delete(line - 1)
+                hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
+                                              location: nil)
+              else
+                hash[line] = comment
+              end
+            end
+          end
+        end
+      else
+        require "ripper"
+        def parse_comments(string, include_trailing:)
+          Ripper.lex(string).yield_self do |tokens|
+            code_lines = {} #: Hash[Integer, bool]
+            tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
+              case token[1]
+              when :on_sp, :on_ignored_nl
+                # skip
+              when :on_comment
+                line = token[0][0]
+                # skip like `module Foo # :nodoc:`
+                next if code_lines[line] && !include_trailing
+                body = token[2][2..-1] or raise
+
+                body = "\n" if body.empty?
+
+                comment = AST::Comment.new(string: body, location: nil)
+                if prev_comment = hash.delete(line - 1)
+                  hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
+                                                location: nil)
+                else
+                  hash[line] = comment
+                end
+              else
+                code_lines[token[0][0]] = true
+              end
+            end
+          end
+        end
+      end
+
       def block_from_body(node)
         _, args_node, body_node = node.children
         _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block_var = args_from_node(args_node)

data/lib/rbs/prototype/rb.rb

@@ -74,32 +74,7 @@ module RBS
 
       def parse(string)
         # @type var comments: Hash[Integer, AST::Comment]
-        comments = Ripper.lex(string).yield_self do |tokens|
-          code_lines = {} #: Hash[Integer, bool]
-          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
-            case token[1]
-            when :on_sp, :on_ignored_nl
-              # skip
-            when :on_comment
-              line = token[0][0]
-              # skip like `module Foo # :nodoc:`
-              next if code_lines[line]
-              body = token[2][2..-1] or raise
-
-              body = "\n" if body.empty?
-
-              comment = AST::Comment.new(string: body, location: nil)
-              if prev_comment = hash.delete(line - 1)
-                hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
-                                              location: nil)
-              else
-                hash[line] = comment
-              end
-            else
-              code_lines[token[0][0]] = true
-            end
-          end
-        end
+        comments = parse_comments(string, include_trailing: false)
 
         process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, context: Context.initial
       end
@@ -372,8 +347,8 @@ module RBS
                        end
 
           value_node = node.children.last
-          type = if value_node.nil?
-                  # Give up type prediction when node is MASGN.
+          type = if value_node.nil? || value_node.type == :SELF
+                  # Give up type prediction when node is MASGN or SELF.
                   Types::Bases::Any.new(location: nil)
                 else
                   literal_to_type(value_node)

data/lib/rbs/prototype/rbi.rb

@@ -16,26 +16,7 @@ module RBS
       end
 
       def parse(string)
-        comments = Ripper.lex(string).yield_self do |tokens|
-          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
-            if token[1] == :on_comment
-              line = token[0][0]
-              body = token[2][2..-1] or raise
-
-              body = "\n" if body.empty?
-
-              comment = AST::Comment.new(string: body, location: nil)
-              if (prev_comment = hash.delete(line - 1))
-                hash[line] = AST::Comment.new(
-                  string: prev_comment.string + comment.string,
-                  location: nil
-                )
-              else
-                hash[line] = comment
-              end
-            end
-          end
-        end
+        comments = parse_comments(string, include_trailing: true)
         process RubyVM::AbstractSyntaxTree.parse(string), comments: comments
       end
 
@@ -235,6 +216,7 @@ module RBS
                 variance: variance || :invariant,
                 location: nil,
                 upper_bound: nil,
+                lower_bound: nil,
                 default_type: nil
               )
             end
@@ -332,6 +314,7 @@ module RBS
                   name: name,
                   variance: :invariant,
                   upper_bound: nil,
+                  lower_bound: nil,
                   location: nil,
                   default_type: nil
                 )

data/lib/rbs/prototype/runtime.rb

@@ -27,6 +27,10 @@ module RBS
           method_definition = @builder.build_singleton(module_name.absolute!).methods[method.name]
           return false unless method_definition
 
+          return false unless method_definition.defs.any? do |type_def|
+            type_def.implemented_in&.relative!.to_s == method.owner.to_s.delete_prefix("#<Class:").delete_suffix(">")
+          end
+
           method_definition.accessibility == accessibility
         end
 
@@ -36,6 +40,10 @@ module RBS
           method_definition = @builder.build_instance(module_name.absolute!).methods[method.name]
           return false unless method_definition
 
+          return false unless method_definition.defs.any? do |type_def|
+            type_def.implemented_in&.relative!.to_s == method.owner.to_s
+          end
+
           method_definition.accessibility == accessibility
         end
 
@@ -69,6 +77,8 @@ module RBS
       attr_accessor :outline
 
       def initialize(patterns:, env:, merge:, todo: false, owners_included: [])
+        Kernel.warn("RBS::Prototype::Runtime is deprecated. See https://github.com/ruby/rbs/issues/2841")
+
         @patterns = patterns
         @decls = nil
         @modules = {}

data/lib/rbs/resolver/constant_resolver.rb

@@ -32,7 +32,7 @@ module RBS
           end
 
           environment.class_alias_decls.each do |name, entry|
-            normalized_entry = environment.normalized_module_class_entry(name) or next
+            normalized_entry = environment.module_class_entry(name, normalized: true) or next
             constant = constant_of_module(name, normalized_entry)
 
             # Insert class/module aliases into `children_table` and `toplevel` table
@@ -176,7 +176,7 @@ module RBS
       end
 
       def constants_from_ancestors(module_name, constants:)
-        entry = builder.env.normalized_module_class_entry(module_name) or raise
+        entry = builder.env.module_class_entry(module_name, normalized: true) or raise
 
         if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
           constants.merge!(table.children(BuiltinNames::Object.name) || raise)

data/lib/rbs/resolver/type_name_resolver.rb

@@ -5,85 +5,161 @@ module RBS
     class TypeNameResolver
       attr_reader :all_names
       attr_reader :cache
-      attr_reader :env
+      attr_reader :aliases
 
-      def initialize(env)
-        @all_names = Set[]
+      def initialize(all_names, aliases)
+        @all_names = all_names
+        @aliases = aliases
         @cache = {}
-        @env = env
+      end
+
+      def self.build(env)
+        all_names = Set.new #: Set[TypeName]
 
         all_names.merge(env.class_decls.keys)
         all_names.merge(env.interface_decls.keys)
         all_names.merge(env.type_alias_decls.keys)
-        all_names.merge(env.class_alias_decls.keys)
-      end
 
-      def try_cache(query)
-        cache.fetch(query) do
-          result = yield
-          cache[query] = result
+        aliases = {} #: Hash[TypeName, [TypeName, context]]
+
+        env.class_alias_decls.each do |name, entry|
+          aliases[name] = [entry.decl.old_name, entry.context]
         end
+
+        new(all_names, aliases)
+      end
+
+      def try_cache(type_name, context)
+        inner = cache[context] ||= {}
+        inner.fetch(type_name) { inner[type_name] = yield }
       end
 
       def resolve(type_name, context:)
-        if type_name.absolute?
+        if type_name.absolute? && has_type_name?(type_name)
           return type_name
         end
 
-        try_cache([type_name, context]) do
-          head, tail = partition(type_name)
-
-          head = resolve_in(head, context)
+        try_cache(type_name, context) do
+          if type_name.class?
+            resolve_namespace0(type_name, context, Set.new) || nil
+          else
+            namespace = type_name.namespace
 
-          if head
-            if tail
-              absolute_name = tail.with_prefix(head.to_namespace)
-              if env.normalize_type_name?(absolute_name)
-                absolute_name
-              end
+            if namespace.empty?
+              resolve_type_name(type_name.name, context)
             else
-              head
+              if namespace = resolve_namespace0(namespace.to_type_name, context, Set.new)
+                type_name = TypeName[namespace.to_namespace, type_name.name]
+                has_type_name?(type_name)
+              end
             end
           end
         end
       end
 
-      def partition(type_name)
-        if type_name.namespace.empty?
-          head = type_name.name
-          tail = nil
-        else
-          head, *tail = type_name.namespace.path
+      def resolve_namespace(type_name, context:)
+        if type_name.absolute? && has_type_name?(type_name)
+          return type_name
+        end
 
-          head or raise
+        unless type_name.class?
+          raise "Type name must be a class name: #{type_name}"
+        end
 
-          tail = TypeName.new(
-            name: type_name.name,
-            namespace: Namespace.new(absolute: false, path: tail)
-          )
+        try_cache(type_name, context) do
+          ns = resolve_namespace0(type_name, context, Set.new) or return ns
         end
+      end
 
-        [head, tail]
+      def has_type_name?(full_name)
+        if all_names.include?(full_name)
+          full_name
+        end
       end
 
-      def resolve_in(head, context)
+      def aliased_name?(type_name)
+        if aliases.key?(type_name)
+          type_name
+        end
+      end
+
+      def resolve_type_name(type_name, context)
         if context
-          parent, child = context
-          case child
+          outer, inner = context
+          case inner
           when false
-            resolve_in(head, parent)
+            resolve_type_name(type_name, outer)
+          else
+            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
+            has_type_name?(TypeName[inner.to_namespace, type_name]) || resolve_type_name(type_name, outer)
+          end
+        else
+          type_name = TypeName[Namespace.root, type_name]
+          has_type_name?(type_name)
+        end
+      end
+
+      def resolve_head_namespace(head, context)
+        if context
+          outer, inner = context
+          case inner
+          when false
+            resolve_head_namespace(head, outer)
           when TypeName
-            name = TypeName.new(name: head, namespace: child.to_namespace)
-            has_name?(name) || resolve_in(head, parent)
+            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
+            type_name = TypeName[inner.to_namespace, head]
+            has_type_name?(type_name) || aliased_name?(type_name) || resolve_head_namespace(head, outer)
           end
         else
-          has_name?(TypeName.new(name: head, namespace: Namespace.root))
+          type_name = TypeName[Namespace.root, head]
+          has_type_name?(type_name) || aliased_name?(type_name)
         end
       end
 
-      def has_name?(full_name)
-        if all_names.include?(full_name)
-          full_name
+      def normalize_namespace(type_name, rhs, context, visited)
+        if visited.include?(type_name)
+          # Cycle detected
+          return false
+        end
+
+        visited << type_name
+
+        begin
+          resolve_namespace0(rhs, context, visited)
+        ensure
+          visited.delete(type_name)
+        end
+      end
+
+      def resolve_namespace0(type_name, context, visited)
+        head, *tail = [*type_name.namespace.path, type_name.name]
+
+        head = head #: Symbol
+
+        head =
+          if type_name.absolute?
+            root_name = TypeName[Namespace.root, head]
+            has_type_name?(root_name) || aliased_name?(root_name)
+          else
+            resolve_head_namespace(head, context)
+          end
+
+        if head
+          if (rhs, context = aliases.fetch(head, nil))
+            head = normalize_namespace(head, rhs, context, visited) or return head
+          end
+
+          tail.inject(head) do |namespace, name|
+            type_name = TypeName[namespace.to_namespace, name]
+            case
+            when has_type_name?(type_name)
+              type_name
+            when (rhs, context = aliases.fetch(type_name, nil))
+              m = normalize_namespace(type_name, rhs, context, visited) or return m
+            else
+              return nil
+            end
+          end
         end
       end
     end

data/lib/rbs/rewriter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RBS
+  class Rewriter
+    attr_reader :buffer
+
+    def initialize(buffer)
+      raise "Rewriter only supports toplevel buffers" if buffer.parent
+
+      @buffer = buffer
+      @rewrites = []
+    end
+
+    def rewrite(location, string)
+      @rewrites.each do |existing_location, _|
+        if location.start_pos < existing_location.end_pos && existing_location.start_pos < location.end_pos
+          raise "Overlapping rewrites: #{existing_location} and #{location}"
+        end
+      end
+
+      @rewrites << [location, string]
+      self
+    end
+
+    def add_comment(*locations, content:)
+      earliest = locations.min_by(&:start_pos) or raise "At least one location is required"
+      insert_pos = earliest.start_pos
+      indent = " " * earliest.start_column
+
+      formatted = format_comment(content, indent)
+
+      loc = Location.new(buffer, insert_pos, insert_pos)
+      rewrite(loc, "#{formatted}\n#{indent}")
+    end
+
+    def replace_comment(comment, content:)
+      location = comment.location or raise "Comment must have a location"
+      indent = " " * location.start_column
+
+      rewrite(location, format_comment(content, indent))
+    end
+
+    def delete_comment(comment)
+      location = comment.location or raise "Comment must have a location"
+      line_start = location.start_pos - location.start_column
+      line_end = location.end_pos + 1
+      loc = Location.new(buffer, line_start, line_end)
+      rewrite(loc, "")
+    end
+
+    def string
+      result = buffer.content.dup
+
+      @rewrites.sort_by { |location, _| location.start_pos }.reverse_each do |location, replacement|
+        result[location.start_pos...location.end_pos] = replacement
+      end
+
+      result
+    end
+
+    private
+
+    def format_comment(content, indent)
+      content.lines.map do |line|
+        line = line.chomp
+        line.empty? ? "#" : "# #{line}"
+      end.join("\n#{indent}")
+    end
+  end
+end

data/lib/rbs/subtractor.rb

@@ -107,7 +107,9 @@ module RBS
       each_member(owner).any? do |m|
         case m
         when AST::Members::InstanceVariable
-          m.name == name
+          m.name == name && kind == :instance
+        when AST::Members::ClassInstanceVariable
+          m.name == name && kind == :singleton
         when AST::Members::Attribute
           ivar_name = m.ivar_name == false ? nil : m.ivar_name || :"@#{m.name}"
           ivar_name == name && m.kind == kind

data/lib/rbs/test/type_check.rb

@@ -245,7 +245,7 @@ module RBS
         when Types::Bases::Any
           true
         when Types::Bases::Bool
-          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+          Test.call(val, IS_AP, TrueClass) || Test.call(val, IS_AP, FalseClass)
         when Types::Bases::Top
           true
         when Types::Bases::Bottom
@@ -264,6 +264,9 @@ module RBS
           klass = get_class(type.name) or return false
           if params = builder.env.normalized_module_class_entry(type.name.absolute!)&.type_params
             args = AST::TypeParam.normalize_args(params, type.args)
+            if args.size != params.size
+              return false
+            end
             unless args == type.args
               type = Types::ClassInstance.new(name: type.name, args: args, location: type.location)
             end
@@ -288,6 +291,19 @@ module RBS
                   values << args
                   nil
                 end
+              when nil
+                values = []
+                count = 10_000
+
+                ret = val.each do |*args|
+                  count -= 1
+                  values << args
+                  break if count <= 0
+                end
+
+                if count == 0
+                  ret = self
+                end
               else
                 values = []
                 ret = val.each do |*args|
@@ -323,7 +339,7 @@ module RBS
                             rescue TypeError
                               return false
                             end
-          val.is_a?(singleton_class)
+          Test.call(val, IS_AP, singleton_class)
         when Types::Interface
           if (definition = builder.build_interface(type.name.absolute!))
             definition.methods.each.all? do |method_name, method|
@@ -340,7 +356,12 @@ module RBS
         when Types::Variable
           true
         when Types::Literal
-          type.literal == val
+          begin
+            type.literal == val
+          rescue NoMethodError
+            raise if defined?(val.==)
+            false
+          end
         when Types::Union
           type.types.any? {|type| value(val, type) }
         when Types::Intersection
@@ -351,6 +372,7 @@ module RBS
           value(val, builder.expand_alias2(type.name.absolute!, type.args))
         when Types::Tuple
           Test.call(val, IS_AP, ::Array) &&
+            type.types.length == val.length &&
             type.types.map.with_index {|ty, index| value(val[index], ty) }.all?
         when Types::Record
           Test::call(val, IS_AP, ::Hash) &&