rbs 3.10.0 → 4.0.0.dev.1

data/lib/rbs/resolver/type_name_resolver.rb

@@ -5,36 +5,17 @@ module RBS
     class TypeNameResolver
       attr_reader :all_names
       attr_reader :cache
-      attr_reader :aliases
+      attr_reader :env
 
-      def initialize(all_names, aliases)
-        @all_names = all_names
-        @aliases = aliases
+      def initialize(env)
+        @all_names = Set[]
         @cache = {}
-      end
-
-      def self.new(*args)
-        if args.size == 1 && args[0].is_a?(Environment)
-          build(args[0])
-        else
-          super
-        end
-      end
-
-      def self.build(env)
-        all_names = Set.new #: Set[TypeName]
+        @env = env
 
         all_names.merge(env.class_decls.keys)
         all_names.merge(env.interface_decls.keys)
         all_names.merge(env.type_alias_decls.keys)
-
-        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)
+        all_names.merge(env.class_alias_decls.keys)
       end
 
       def try_cache(query)
@@ -45,131 +26,64 @@ module RBS
       end
 
       def resolve(type_name, context:)
-        if type_name.absolute? && has_type_name?(type_name)
+        if type_name.absolute?
           return type_name
         end
 
         try_cache([type_name, context]) do
-          if type_name.class?
-            resolve_namespace0(type_name, context, Set.new) || nil
-          else
-            namespace = type_name.namespace
+          head, tail = partition(type_name)
 
-            if namespace.empty?
-              resolve_type_name(type_name.name, context)
-            else
-              if namespace = resolve_namespace0(namespace.to_type_name, context, Set.new)
-                type_name = TypeName.new(name: type_name.name, namespace: namespace.to_namespace)
-                has_type_name?(type_name)
+          head = resolve_in(head, context)
+
+          if head
+            if tail
+              absolute_name = tail.with_prefix(head.to_namespace)
+              if env.normalize_type_name?(absolute_name)
+                absolute_name
               end
+            else
+              head
             end
           end
         end
       end
 
-      def resolve_namespace(type_name, context:)
-        if type_name.absolute? && has_type_name?(type_name)
-          return type_name
-        end
-
-        unless type_name.class?
-          raise "Type name must be a class name: #{type_name}"
-        end
+      def partition(type_name)
+        if type_name.namespace.empty?
+          head = type_name.name
+          tail = nil
+        else
+          head, *tail = type_name.namespace.path
 
-        try_cache([type_name, context]) do
-          ns = resolve_namespace0(type_name, context, Set.new) or return ns
-        end
-      end
+          head or raise
 
-      def has_type_name?(full_name)
-        if all_names.include?(full_name)
-          full_name
+          tail = TypeName.new(
+            name: type_name.name,
+            namespace: Namespace.new(absolute: false, path: tail)
+          )
         end
-      end
 
-      def aliased_name?(type_name)
-        if aliases.key?(type_name)
-          type_name
-        end
+        [head, tail]
       end
 
-      def resolve_type_name(type_name, context)
+      def resolve_in(head, context)
         if context
-          outer, inner = context
-          case inner
+          parent, child = context
+          case child
           when false
-            resolve_type_name(type_name, outer)
-          else
-            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
-            has_type_name?(TypeName.new(name: type_name, namespace: inner.to_namespace)) || resolve_type_name(type_name, outer)
-          end
-        else
-          type_name = TypeName.new(name: type_name, namespace: Namespace.root)
-          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)
+            resolve_in(head, parent)
           when TypeName
-            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
-            type_name = TypeName.new(name: head, namespace: inner.to_namespace)
-            has_type_name?(type_name) || aliased_name?(type_name) || resolve_head_namespace(head, outer)
+            name = TypeName.new(name: head, namespace: child.to_namespace)
+            has_name?(name) || resolve_in(head, parent)
           end
         else
-          type_name = TypeName.new(name: head, namespace: Namespace.root)
-          has_type_name?(type_name) || aliased_name?(type_name)
-        end
-      end
-
-      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)
+          has_name?(TypeName.new(name: head, namespace: Namespace.root))
         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.new(name: head, namespace: Namespace.root)
-            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.new(name: name, namespace: namespace.to_namespace)
-            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
+      def has_name?(full_name)
+        if all_names.include?(full_name)
+          full_name
         end
       end
     end

data/lib/rbs/source.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RBS
+  module Source
+    class RBS
+      attr_reader :buffer, :directives, :declarations
+
+      def initialize(buffer, directives, decls)
+        @buffer = buffer
+        @directives = directives
+        @declarations = decls
+      end
+
+      def each_type_name(&block)
+        if block
+          set = Set[] #: Set[TypeName]
+          declarations.each do |decl|
+            each_declaration_type_name(set, decl, &block)
+          end
+        else
+          enum_for :each_type_name
+        end
+      end
+
+      def each_declaration_type_name(names, decl, &block)
+        case decl
+        when AST::Declarations::Class
+          decl.each_decl { each_declaration_type_name(names, _1, &block) }
+          type_name = decl.name
+        when AST::Declarations::Module
+          decl.each_decl { each_declaration_type_name(names, _1, &block) }
+          type_name = decl.name
+        when AST::Declarations::Interface
+          type_name = decl.name
+        when AST::Declarations::TypeAlias
+          type_name = decl.name
+        when AST::Declarations::ModuleAlias
+          type_name = decl.new_name
+        when AST::Declarations::ClassAlias
+          type_name = decl.new_name
+        end
+
+        if type_name
+          unless names.include?(type_name)
+            yield type_name
+            names << type_name
+          end
+        end
+      end
+    end
+
+    class Ruby
+      attr_reader :buffer
+      attr_reader :prism_result
+      attr_reader :declarations
+      attr_reader :diagnostics
+
+      def initialize(buffer, prism, declarations, diagnostics)
+        @buffer = buffer
+        @prism_result = prism
+        @declarations = declarations
+        @diagnostics = diagnostics
+      end
+
+      def each_type_name(&block)
+        if block
+          names = Set[] #: Set[TypeName]
+          declarations.each do |decl|
+            each_declaration_type_name(names, decl, &block)
+          end
+        else
+          enum_for :each_type_name
+        end
+      end
+
+      def each_declaration_type_name(names, decl, &block)
+        case decl
+        when AST::Ruby::Declarations::ClassDecl
+          decl.each_decl do |d|
+            each_declaration_type_name(names, d, &block)
+          end
+          type_name = decl.class_name
+        when AST::Ruby::Declarations::ModuleDecl
+          decl.each_decl do |d|
+            each_declaration_type_name(names, d, &block)
+          end
+          type_name = decl.module_name
+        end
+
+        if type_name
+          unless names.include?(type_name)
+            yield type_name
+            names << type_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/subtractor.rb

@@ -129,9 +129,10 @@ module RBS
 
       entry = @subtrahend.class_decls[owner]
       return unless entry
-      decls = entry.decls.map { |d| d.decl }
-
-      decls.each { |d| d.members.each { |m| block.call(m) } }
+      entry.each_decl do |d|
+        next unless d.is_a?(AST::Declarations::Base)
+        d.members.each { |m| block.call(m) }
+      end
     end
 
     private def mixin_exist?(owner, mixin, context:)

data/lib/rbs/test/type_check.rb

@@ -288,19 +288,6 @@ 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|
@@ -364,7 +351,6 @@ 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) &&

data/lib/rbs/types.rb

@@ -1339,10 +1339,8 @@ module RBS
       attr_reader :type
       attr_reader :required
       attr_reader :self_type
-      attr_reader :location
 
-      def initialize(location: nil, type:, required:, self_type: nil)
-        @location = location
+      def initialize(type:, required:, self_type: nil)
         @type = type
         @required = required ? true : false
         @self_type = self_type

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.10.0"
+  VERSION = "4.0.0.dev.1"
 end

data/lib/rbs.rb

@@ -4,12 +4,13 @@ require "rbs/version"
 
 require "set"
 require "json"
-require "pathname" unless defined?(Pathname)
+require "pathname"
 require "pp"
 require "ripper"
 require "logger"
 require "tsort"
 require "strscan"
+require "prism"
 
 require "rbs/errors"
 require "rbs/buffer"
@@ -24,8 +25,19 @@ require "rbs/ast/declarations"
 require "rbs/ast/members"
 require "rbs/ast/annotation"
 require "rbs/ast/visitor"
+require "rbs/ast/ruby/comment_block"
+require "rbs/ast/ruby/helpers/constant_helper"
+require "rbs/ast/ruby/helpers/location_helper"
+require "rbs/ast/ruby/annotations"
+require "rbs/ast/ruby/declarations"
+require "rbs/ast/ruby/members"
+require "rbs/source"
+require "rbs/inline_parser"
+require "rbs/inline_parser/comment_association"
 require "rbs/environment"
 require "rbs/environment/use_map"
+require "rbs/environment/class_entry"
+require "rbs/environment/module_entry"
 require "rbs/environment_loader"
 require "rbs/builtin_names"
 require "rbs/definition"

data/lib/rdoc/discover.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 begin
-  gem 'rdoc', '>= 6.16'
+  gem 'rdoc', '~> 6.13'
   require 'rdoc_plugin/parser'
   module RDoc
     class Parser

data/lib/rdoc_plugin/parser.rb

@@ -76,7 +76,7 @@ module RBS
         method.visibility = decl.visibility
         method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
         if loc = decl.location
-          method.start_collecting_tokens(:ruby)
+          method.start_collecting_tokens
           method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })
           method.add_token({ line_no: 1, char_no: 1, text: loc.source })
           method.line = loc.start_line

data/rbs.gemspec

@@ -46,4 +46,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.required_ruby_version = ">= 3.1"
   spec.add_dependency "logger"
+  spec.add_dependency "prism", ">= 1.3.0"
 end

data/sig/ancestor_builder.rbs

@@ -146,7 +146,7 @@ module RBS
                             extended_modules: Array[Definition::Ancestor::Instance]?,
                          extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
 
-      def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface,
+      def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface | AST::Ruby::Declarations::ClassDecl | AST::Ruby::Declarations::ModuleDecl,
                              TypeName,
                              align_params: Substitution?,
                          included_modules: Array[Definition::Ancestor::Instance]?,

data/sig/ast/ruby/annotations.rbs

@@ -0,0 +1,110 @@
+module RBS
+  module AST
+    module Ruby
+      module Annotations
+        type leading_annotation = ColonMethodTypeAnnotation
+                                | MethodTypesAnnotation
+                                | SkipAnnotation
+                                | ReturnTypeAnnotation
+
+        type trailing_annotation = NodeTypeAssertion
+
+        type t = leading_annotation | trailing_annotation
+
+        class Base
+          # Location that covers all of the annotation
+          #
+          attr_reader location: Location
+
+          # Location of `@rbs`, `@rbs!`, or `:` prefix
+          #
+          attr_reader prefix_location: Location
+
+          def initialize: (Location location, Location prefix_location) -> void
+
+          def buffer: () -> Buffer
+        end
+
+        # `: TYPE` annotation attached to nodes
+        #
+        class NodeTypeAssertion < Base
+          attr_reader type: Types::t
+
+          def initialize: (location: Location, prefix_location: Location, type: Types::t) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+        end
+
+        # `: METHOD-TYPE` annotation in leading comments
+        #
+        class ColonMethodTypeAnnotation < Base
+          attr_reader annotations: Array[AST::Annotation]
+
+          attr_reader method_type: MethodType
+
+          def initialize: (location: Location, prefix_location: Location, annotations: Array[AST::Annotation], method_type: MethodType) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+        end
+
+        # `@rbs METHOD-TYPEs` annotation in leading comments
+        #
+        # ```
+        # @rbs () -> void | %a{foo} () -> String
+        # ^^^^                                     -- prefix_location
+        #                 ^                        -- vertical_bar_locations[0]
+        # ```
+        class MethodTypesAnnotation < Base
+          class Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader overloads: Array[Overload]
+
+          attr_reader vertical_bar_locations: Array[Location]
+
+          def initialize: (location: Location, prefix_location: Location, overloads: Array[Overload], vertical_bar_locations: Array[Location]) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+        end
+
+        # `@rbs skip -- comment` annotation in leading comments
+        #
+        class SkipAnnotation < Base
+          attr_reader skip_location: Location
+          attr_reader comment_location: Location?
+
+          def initialize: (location: Location, prefix_location: Location, skip_location: Location, comment_location: Location?) -> void
+        end
+
+        # `@rbs return: T -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs return: String -- Returns a string
+        # ^^^                                        -- prefix_location
+        #      ^^^^^^                                -- return_location
+        #            ^                               -- colon_location
+        #                     ^^^^^^^^^^^^^^^^^^^    -- comment
+        # ```
+        class ReturnTypeAnnotation < Base
+          attr_reader return_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader return_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            return_location: Location,
+            colon_location: Location,
+            return_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/comment_block.rbs

@@ -0,0 +1,119 @@
+use Prism::Comment
+
+module RBS
+  module AST
+    module Ruby
+      # CommentBlock is a collection of comments
+      #
+      # ```ruby
+      # # Comment1      < block1
+      # # Comment2      <
+      #
+      # # Comment3      < block2
+      # ```
+      #
+      # A comment block is a *leading* block or *trailing* block.
+      #
+      # ```ruby
+      # # This is leading block.
+      # # This is the second line of the leading block.
+      #
+      # foo      # This is trailing block.
+      #          # This is second line of the trailing block.
+      # ```
+      #
+      # A leading block is a comment block where all of the comments are at the start of the line content.
+      # A trailing block is a comment block where the first comment of the block has something at the line before the comment.
+      #
+      class CommentBlock
+        attr_reader name: Pathname
+
+        # Sub buffer of the contents of the comments
+        #
+        attr_reader comment_buffer: Buffer
+
+        attr_reader offsets: Array[
+          [
+            Comment,
+            Integer, # -- prefix size
+          ]
+        ]
+
+        def initialize: (Buffer source_buffer, Array[Comment]) -> void
+
+        # Build comment block instances
+        def self.build: (Buffer, Array[Comment]) -> Array[instance]
+
+        # Returns true if the comment block is a *leading* comment, which is attached to the successor node
+        def leading?: () -> bool
+
+        # Returns true if the comment block is a *trailing* comment, which is attached to the predecessor node
+        def trailing?: () -> bool
+
+        # The line number of the first comment in the block
+        def start_line: () -> Integer
+
+        # The line number of the last comment in the block
+        def end_line: () -> Integer
+
+        # The character index of `#comment_buffer` at the start of the lines
+        #
+        def line_starts: () -> Array[Integer]
+
+        # Returns the text content of the comment
+        def text: (Integer index) -> String
+
+        # Yields paragraph and annotation
+        #
+        # A paragraph is a sequence of lines that are separated by annotations.
+        # An annotation starts with a line starting with `@rbs` or `:`, and may continue with lines that has more leading spaces.
+        #
+        # ```
+        # # Line 1         ^ Paragraph 1
+        # #   Line 2       |
+        # #                |
+        # # Line 3         v
+        # # @rbs ...       < Annotation 1
+        # # @rbs ...       ^ Annotation 2
+        # #   ...          |
+        # #                |
+        # #   ...          v
+        # #                ^ Paragraph 2
+        # # Line 4         |
+        # # Line 5         v
+        # ```
+        #
+        def each_paragraph: (Array[Symbol] variables) { (Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError) -> void } -> void
+                          | (Array[Symbol] variables) -> Enumerator[Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError]
+
+        # Returns a trailing annotation if it exists
+        #
+        # * Returns `nil` if the block is not a type annotation
+        # * Returns an annotation if the block has a type annotation
+        # * Returns AnnotationSyntaxError if the annotation has a syntax error
+        #
+        def trailing_annotation: (Array[Symbol] variables) -> (AST::Ruby::Annotations::trailing_annotation | AnnotationSyntaxError | nil)
+
+        class AnnotationSyntaxError
+          attr_reader location: Location
+
+          attr_reader error: ParsingError
+
+          def initialize: (Location, ParsingError) -> void
+        end
+
+        private def yield_paragraph: (Integer start_line, Integer current_line, Array[Symbol] variables) { (Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError) -> void } -> void
+
+        private def yield_annotation: (Integer start_line, Integer end_line, Integer current_line, Array[Symbol] variables) { (Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError) -> void } -> void
+
+        private def parse_annotation_lines: (Integer start_line, Integer end_line, Array[Symbol] variables) -> (AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError)
+
+        def comments: () -> Array[Comment]
+
+        def line_location: (Integer start_line, Integer end_line) -> Location
+
+        private def leading_annotation?: (Integer index) -> bool
+      end
+    end
+  end
+end