rbs 3.10.0 → 4.0.0.dev.1

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
-
-      @context: Resolver::context
+      attr_reader 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.
@@ -190,58 +132,22 @@ module RBS
     # Returns true if the type name is a class alias
     def class_alias?: (TypeName) -> bool
 
-    # Returns the entry for the class name
-    #
-    # Returns `nil` when:
-    #
-    # * The type name is not found
-    # * The type name is not a class
-    #
-    # It normalizes when `normalized: true` is given -- returns `ClassEntry` or `nil`.
-    #
-    def class_entry: (TypeName, normalized: true) -> ClassEntry?
-                   | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | nil)
+    def class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | nil)
 
     # Returns ClassEntry if the class definition is found, normalized in case of alias
     #
-    %a{deprecated: Use `class_entry(type_name, normalized: true)` instead. }
     def normalized_class_entry: (TypeName) -> ClassEntry?
 
-    # Returns the entry for the module name
-    #
-    # Returns `nil` when:
-    #
-    # * The type name is not found
-    # * The type name is not a module
-    #
-    # It normalizes when `normalized: true` is given -- returns `ModuleEntry` or `nil`.
-    #
-    def module_entry: (TypeName, normalized: true) -> ModuleEntry?
-                    | (TypeName, ?normalized: bool) -> (ModuleEntry | ModuleAliasEntry | nil)
+    def module_entry: (TypeName) -> (ModuleEntry | ModuleAliasEntry | nil)
 
     # Returns ModuleEntry if the module definition is found, normalized in case of alias
     #
-    %a{deprecated: Use `module_entry(type_name, normalized: true)` instead. }
     def normalized_module_entry: (TypeName) -> ModuleEntry?
 
-    # Returns the entry for the type name
-    #
-    # The entry is one of ClassEntry, ModuleEntry, ConstantEntry, ClassAliasEntry, or ModuleAliasEntry.
-    # When `normalized: true` is given, it returns normalized entry -- one of ClassEntry, ModuleEntry, or ConstantEntry.
-    #
-    # Returns `nil` if not found.
-    #
-    def constant_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | ConstantEntry | nil)
-                      | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
+    def constant_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
 
-    # Returns ClassEntry or ModuleEntry if the class/module definition is found
-    #
-    # Normalizes when `normalized: true` is given.
-    #
-    def module_class_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | nil)
-                          | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
+    def module_class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
 
-    %a{deprecated: Use `module_class_entry(type_name, normalized: true)` instead. }
     def normalized_module_class_entry: (TypeName) -> (ClassEntry | ModuleEntry | nil)
 
     @normalize_module_name_cache: Hash[TypeName, TypeName | false | nil]
@@ -252,39 +158,26 @@ module RBS
     # * Returns `nil` if the rhs name cannot be found
     # * Returns `false` if the name is cyclic
     #
-    # Note that this method assumes the declarations have resolved type names.
-    #
     def normalize_module_name?: (TypeName) -> (TypeName | nil | false)
 
-    # Returns the original module name that is defined with `module`/`class` declaration
+    # Returns the original module name that is defined with `module` declaration
     #
-    # * Raises an error if given type name is not module/class
+    # * Raises an error if given type name is not module
     # * Calls `#absolute!` for relative module names
     # * Returns the name itself if the name cannot be normalized to a class/module
     #
-    # Note that this method assumes the declarations have resolved type names.
-    #
     def normalize_module_name: (TypeName) -> TypeName
 
-    # Returns the original module name that is defined with `module`/`class` declaration
-    #
-    # * Raises an error if given type name is not a module/class
-    def normalize_module_name!: (TypeName) -> TypeName
-
     # Returns a normalized module/class name or a type name with a normalized namespace
     #
     # * Calls `#absolute!` for relative module names
     # * Returns `nil` if the typename cannot be found
     # * Returns `false` if the name is cyclic
     #
-    # Note that this method assumes the declarations have resolved type names.
-    #
     def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
 
     # Normalize the type name or raises an error
     #
-    # Note that this method assumes the declarations have resolved type names.
-    #
     def normalize_type_name!: (TypeName) -> TypeName
 
     # Returns a normalized module/class name or a type name with a normalized namespace
@@ -292,8 +185,6 @@ module RBS
     # * Calls `#absolute!` for relative module names
     # * Returns the typename itself if the name cannot be normalized
     #
-    # Note that this method assumes the declarations have resolved type names.
-    #
     def normalize_type_name: (TypeName) -> TypeName
 
     # Returns `true` if given type name is normalized
@@ -315,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
 
@@ -323,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