rbs 3.9.2 → 4.0.0.dev.1

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

data/sig/ast/ruby/declarations.rbs

@@ -0,0 +1,60 @@
+module RBS
+  module AST
+    module Ruby
+      module Declarations
+        type t = ClassDecl | ModuleDecl
+
+        class Base
+          attr_reader buffer: Buffer
+
+          include Helpers::ConstantHelper
+          include Helpers::LocationHelper
+
+          def initialize: (Buffer) -> void
+        end
+
+        class ClassDecl < Base
+          type member = t | Members::t
+
+          attr_reader class_name: TypeName
+
+          attr_reader node: Prism::ClassNode
+
+          attr_reader members: Array[member]
+
+          def initialize: (Buffer, TypeName, Prism::ClassNode) -> void
+
+          def each_decl: () { (t) -> void } -> void
+                        | () -> Enumerator[t]
+
+          def super_class: () -> nil
+
+          def type_params: () -> Array[AST::TypeParam]
+
+          def location: () -> Location
+        end
+
+        class ModuleDecl < Base
+          type member = t | Members::t
+
+          attr_reader module_name: TypeName
+
+          attr_reader node: Prism::ModuleNode
+
+          attr_reader members: Array[member]
+
+          def initialize: (Buffer, TypeName, Prism::ModuleNode) -> void
+
+          def each_decl: () { (t) -> void } -> void
+                        | () -> Enumerator[t]
+
+          def type_params: () -> Array[AST::TypeParam]
+
+          def location: () -> Location
+
+          def self_types: () -> Array[AST::Declarations::Module::Self]
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/helpers/constant_helper.rbs

@@ -0,0 +1,11 @@
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module ConstantHelper
+          def self?.constant_as_type_name: (Prism::node?) -> TypeName?
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/helpers/location_helper.rbs

@@ -0,0 +1,15 @@
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module LocationHelper : _WithBuffer
+          interface _WithBuffer
+            def buffer: () -> Buffer
+          end
+          
+          def rbs_location: (Prism::Location) -> Location
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/members.rbs

@@ -0,0 +1,72 @@
+module RBS
+  module AST
+    module Ruby
+      module Members
+        class Base
+          attr_reader buffer: Buffer
+
+          def initialize: (Buffer) -> void
+
+          include Helpers::LocationHelper
+        end
+
+        type t = DefMember
+
+        class MethodTypeAnnotation
+          class DocStyle
+            attr_accessor return_type_annotation: Annotations::ReturnTypeAnnotation | Annotations::NodeTypeAssertion | nil
+
+            def initialize: () -> void
+
+            def map_type_name: () { (TypeName) -> TypeName } -> self
+
+            def method_type: () -> MethodType
+          end
+
+          type type_annotations = DocStyle | Array[Annotations::ColonMethodTypeAnnotation | Annotations::MethodTypesAnnotation] | nil
+
+          attr_reader type_annotations: type_annotations
+
+          def initialize: (type_annotations: type_annotations) -> void
+
+          def map_type_name: { (TypeName) -> TypeName } -> self
+
+          # Returns the method type annotations from the comment block
+          #
+          # Returns a tuple of `DefAnnotations` object, array of unused leading annotations, and unused trailing annotation.
+          #
+          def self.build: (CommentBlock? leading_block, CommentBlock? trailing_block, Array[Symbol]) -> [
+            MethodTypeAnnotation,
+            Array[Annotations::leading_annotation | CommentBlock::AnnotationSyntaxError],
+            Annotations::trailing_annotation | CommentBlock::AnnotationSyntaxError | nil
+          ]
+
+          # Returns `true` if it doesn't have any annotation
+          def empty?: () -> bool
+
+          # Returns the method type overloads
+          #
+          def overloads: () -> Array[AST::Members::MethodDefinition::Overload]
+        end
+
+        class DefMember < Base
+          class Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader name: Symbol
+          attr_reader node: Prism::DefNode
+          attr_reader method_type: MethodTypeAnnotation
+
+          def initialize: (Buffer, Symbol name, Prism::DefNode node, MethodTypeAnnotation) -> void
+
+          def location: () -> Location
+
+          def overloads: () -> Array[Overload]
+
+          def overloading?: () -> bool
+
+          def annotations: () -> Array[AST::Annotation]
+        end
+      end
+    end
+  end
+end

data/sig/buffer.rbs

@@ -6,21 +6,45 @@ module RBS
     type loc = [Integer, Integer]
 
     # Name to identify Buffer.
-    attr_reader name: untyped
+    attr_reader name: Pathname
 
     # The content of the buffer.
     attr_reader content: String
 
-    @lines: Array[String]
+    attr_reader parent: [Buffer, Array[Range[Integer]]]?
 
-    @ranges: Array[Range[Integer]]
-
-    def initialize: (name: untyped name, content: String content) -> void
+    def initialize: (name: Pathname name, content: String content) -> void
+                  | (content: String content, parent: [Buffer, Array[Range[Integer]]] parent) -> void
 
+    # Array of lines of the content, without the EOL
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: "123\nabc")
+    # buffer.lines   # => ["123", "abc"]
+    # ```
+    #
+    # If the input has EOL at the end of the file, the `lines` has an empty string at the end.
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: "123\nabc\n")
+    # buffer.lines   # => ["123", "abc", ""]
+    # ```
+    #
     def lines: () -> Array[String]
 
+    @ranges: Array[Range[Integer]]?
+    # Array of ranges that stores the ranges of the each line, without the EOL
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: "123\nabc\n")
+    # buffer.ranges  # => [0...3, 4...7, 8...8]
+    # ```
+    #
     def ranges: () -> Array[Range[Integer]]
 
+    # Returns the number of the lines
+    def line_count: () -> Integer
+
     # Translate position to location.
     def pos_to_loc: (Integer pos) -> loc
 
@@ -28,5 +52,39 @@ module RBS
     def loc_to_pos: (loc loc) -> Integer
 
     def last_position: () -> Integer
+
+    # Translate `Prism::Location` to `RBS::Location` attached to this buffer
+    #
+    # It assumes the `Prism::Location` has a source which is equivalent to `self`.
+    #
+    def rbs_location: (Prism::Location) -> Location
+                    | (Prism::Location, Prism::Location) -> Location
+
+    # Construct a buffer from substrings of this buffer.
+    #
+    # The returned buffer contains lines from given ranges.
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: <<TEXT)
+    # 12345
+    # abcde
+    # ABCDE
+    # TEXT
+    #
+    # buffer.sub_buffer(lines: [0...1, 2...3])  # => Buffer with content = 1\n34
+    # buffer.sub_buffer(lines: [5..7])          # => Raises an error because the range contains newline
+    # ```
+    #
+    %a{pure} def sub_buffer: (lines: Array[Range[Integer]]) -> Buffer
+
+    %a{pure} def parent_buffer: () -> Buffer?
+
+    %a{pure} def parent_position: (Integer) -> Integer?
+
+    %a{pure} def absolute_position: (Integer) -> Integer?
+
+    %a{pure} def top_buffer: () -> Buffer
+
+    %a{pure} def detach: () -> Buffer
   end
 end

data/sig/definition.rbs

@@ -21,6 +21,7 @@ module RBS
 
     class Method
       type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
+                         | AST::Ruby::Members::DefMember
 
       class TypeDef
         attr_reader type: MethodType

data/sig/definition_builder.rbs

@@ -103,7 +103,7 @@ module RBS
 
     def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
 
-    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
+    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t | AST::Ruby::Declarations::t) -> Location[untyped, untyped]?
 
     def validate_variable: (Definition::Variable) -> void
 

data/sig/environment/class_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ClassEntry.new(TypeName.parse("::String"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Kernel")], declaration]
+    # ```
+    class ClassEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Class | AST::Ruby::Declarations::ClassDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      @primary_decl: declaration?
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Find the *primary* declaration of the class
+      #
+      # * Returns the first declaration with super class
+      # * Returns the first declaration if the declaration doesn't have super class
+      #
+      %a{pure} def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+    end
+  end
+end

data/sig/environment/module_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ModuleEntry.new(TypeName.parse("::Kernel"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Object")], declaration]
+    # ```
+    #
+    class ModuleEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Module | AST::Ruby::Declarations::ModuleDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Returns the first declaration
+      #
+      # This method helps using the class with `ClassEntry` objects.
+      #
+      def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+
+      def self_types: () -> Array[AST::Declarations::Module::Self]
+    end
+  end
+end

data/sig/environment.rbs

@@ -2,75 +2,14 @@ module RBS
   class Environment
     type module_decl = AST::Declarations::Class | AST::Declarations::Module
 
-    interface _ModuleOrClass
-      def name: () -> TypeName
-
-      def type_params: () -> Array[AST::TypeParam]
-    end
-
-    interface _NamedDecl
-      def name: () -> TypeName
-    end
-
-    module ContextUtil
-      def calculate_context: (Array[_NamedDecl]) -> Resolver::context
-    end
-
-    # Name of object, it's (multiple) declarations with the outer module declarations
-    #
-    class MultiEntry[M < _ModuleOrClass]
-      class D[M < _ModuleOrClass]
-        attr_reader decl: M
-        attr_reader outer: Array[module_decl]
-
-        def initialize: (decl: M, outer: Array[module_decl]) -> void
-
-        include ContextUtil
-
-        @context: Resolver::context
-
-        def context: () -> Resolver::context
-      end
-
-      attr_reader name: TypeName
-      attr_reader decls: Array[D[M]]
-
-      @primary: D[M]?
-
-      def initialize: (name: TypeName) -> void
-
-      def insert: (decl: M, outer: Array[module_decl]) -> void
-
-      def validate_type_params: () -> void
-
-      def compatible_params?: (Array[AST::TypeParam], Array[AST::TypeParam]) -> boolish
-
-      def type_params: () -> Array[AST::TypeParam]
-
-      def primary: () -> D[M]
-    end
-
-    class ModuleEntry < MultiEntry[AST::Declarations::Module]
-      def self_types: () -> Array[AST::Declarations::Module::Self]
-    end
-
-    class ClassEntry < MultiEntry[AST::Declarations::Class]
-    end
-
     # Name of object, it's (single) declaration, and the outer module declarations
     #
     class SingleEntry[N, D]
       attr_reader name: N
       attr_reader decl: D
-      attr_reader outer: Array[module_decl]
-
-      def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
-
-      include ContextUtil
+      attr_reader context: Resolver::context
 
-      @context: Resolver::context
-
-      def context: () -> Resolver::context
+      def initialize: (name: N, decl: D, context: Resolver::context) -> void
     end
 
     class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias]
@@ -91,8 +30,9 @@ module RBS
     class GlobalEntry < SingleEntry[Symbol, AST::Declarations::Global]
     end
 
-    # Top level declarations
-    attr_reader declarations: Array[AST::Declarations::t]
+    # Array of source objects loaded in the environment
+    #
+    attr_reader sources: Array[Source::t]
 
     # Class declarations
     attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
@@ -111,10 +51,6 @@ module RBS
     # Global declarations
     attr_reader global_decls: Hash[Symbol, GlobalEntry]
 
-    # A hash from Buffer to it's contents
-    #
-    attr_reader signatures: Hash[Buffer, [Array[AST::Directives::t], Array[AST::Declarations::t]]]
-
     def initialize: () -> void
 
     def initialize_copy: (Environment) -> void
@@ -123,15 +59,21 @@ module RBS
     #
     def self.from_loader: (EnvironmentLoader) -> Environment
 
-    def add_signature: (buffer: Buffer, directives: Array[AST::Directives::t], decls: Array[AST::Declarations::t]) -> void
+    def add_source: (Source::t) -> void
+
+    def each_rbs_source: () { (Source::RBS) -> void } -> void
+                      | () -> Enumerator[Source::RBS]
 
-    # Insert a toplevel declaration into the environment
+    def each_ruby_source: () { (Source::Ruby) -> void } -> void
+                        | () -> Enumerator[Source::Ruby]
+
+    # Insert a declaration into the environment
     #
-    def <<: (AST::Declarations::t decl) -> self
+    private def insert_rbs_decl: (AST::Declarations::t, context: Resolver::context, namespace: Namespace) -> void
 
     # Insert a declaration into the environment
     #
-    private def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
+    private def insert_ruby_decl: (AST::Ruby::Declarations::t, context: Resolver::context, namespace: Namespace) -> void
 
     # Resolve all type names in the environment to absolute type names.
     # Relative type name will be left if absolute type name cannot be found.
@@ -264,7 +206,7 @@ module RBS
 
     def append_context: (Resolver::context, module_decl) -> Resolver::context
 
-    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
+    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, context: Resolver::context, prefix: Namespace) -> AST::Declarations::t
 
     def resolve_member: (Resolver::TypeNameResolver, UseMap map, AST::Members::t, context: Resolver::context) -> AST::Members::t
 
@@ -272,8 +214,12 @@ module RBS
 
     def resolve_type_params: (Resolver::TypeNameResolver resolver, UseMap map, Array[AST::TypeParam], context: Resolver::context) ->  Array[AST::TypeParam]
 
-    def absolute_type: (Resolver::TypeNameResolver, UseMap map, Types::t, context: Resolver::context) -> Types::t
+    def resolve_ruby_decl: (Resolver::TypeNameResolver, AST::Ruby::Declarations::t, context: Resolver::context, prefix: Namespace) -> AST::Ruby::Declarations::t
+
+    def resolve_ruby_member: (Resolver::TypeNameResolver, AST::Ruby::Members::t, context: Resolver::context) -> AST::Ruby::Members::t
+
+    def absolute_type: (Resolver::TypeNameResolver, UseMap? map, Types::t, context: Resolver::context) -> Types::t
 
-    def absolute_type_name: (Resolver::TypeNameResolver, UseMap map, TypeName, context: Resolver::context) -> TypeName
+    def absolute_type_name: (Resolver::TypeNameResolver, UseMap? map, TypeName, context: Resolver::context) -> TypeName
   end
 end

data/sig/errors.rbs

@@ -226,28 +226,35 @@ module RBS
   class InvalidOverloadMethodError < DefinitionError
     include DetailedMessageable
 
+    type member = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
+
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol
     attr_reader kind: :instance | :singleton
-    attr_reader members: Array[AST::Members::MethodDefinition]
+    attr_reader members: Array[member]
 
-    def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[AST::Members::MethodDefinition]) -> void
+    def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[member]) -> void
 
     def location: () -> AST::Members::MethodDefinition::loc?
   end
 
   class GenericParameterMismatchError < LoadingError
+    type decl = AST::Declarations::Class | AST::Declarations::Module
+              | AST::Ruby::Declarations::ClassDecl | AST::Ruby::Declarations::ModuleDecl
+
     attr_reader name: TypeName
-    attr_reader decl: AST::Declarations::Class | AST::Declarations::Module
+    attr_reader decl: decl
 
-    def initialize: (name: TypeName, decl: AST::Declarations::Class | AST::Declarations::Module) -> void
+    def initialize: (name: TypeName, decl: decl, ?location: Location) -> void
   end
 
   class DuplicatedDeclarationError < LoadingError
+    type declaration = AST::Declarations::t | AST::Ruby::Declarations::t
+
     attr_reader name: TypeName | Symbol
-    attr_reader decls: Array[AST::Declarations::t]
+    attr_reader decls: Array[declaration]
 
-    def initialize: (TypeName | Symbol, *AST::Declarations::t) -> void
+    def initialize: (TypeName | Symbol, *declaration) -> void
   end
 
   class InvalidVarianceAnnotationError < DefinitionError