rbs 3.10.0 → 4.0.0.dev.1

data/sig/inline_parser/comment_association.rbs

@@ -0,0 +1,71 @@
+use RBS::AST::Ruby::CommentBlock
+
+module RBS
+  class InlineParser
+    # CommentAssociation manages the association between `Prism::Node` and `CommentBlock`
+    #
+    class CommentAssociation
+      attr_reader blocks: Array[CommentBlock]
+
+      attr_reader start_line_map: Hash[Integer, CommentBlock]
+
+      attr_reader end_line_map: Hash[Integer, CommentBlock]
+
+      # CommentBlocks that are already associated to a node, which cannot be associated to another node again
+      #
+      attr_reader associated_blocks: Set[CommentBlock]
+
+      def self.build: (Buffer, Prism::Result) -> instance
+
+      def initialize: (Array[CommentBlock]) -> void
+
+      class Reference
+        attr_reader block: CommentBlock
+
+        @associated_blocks: Set[CommentBlock]
+
+        def initialize: (CommentBlock, Set[CommentBlock]) -> void
+
+        def associate!: () -> self
+
+        def associated?: () -> bool
+      end
+
+      # Returns an unassociated CommentBlock that can be associated to given node
+      #
+      # Automatically updates association status.
+      #
+      def leading_block!: (Prism::Node) -> CommentBlock?
+
+      # Returns a Reference that is associated to given node
+      #
+      # Updates association explicitly through the reference.
+      #
+      def leading_block: (Prism::Node) -> Reference?
+
+      # Returns a CommentBlock that is associated to given node, or by its location
+      #
+      # Update association status.
+      #
+      def trailing_block!: (Prism::Node | Prism::Location) -> CommentBlock?
+
+      # Returns a Reference that is associated to given node, or by its location
+      #
+      # Updates association explicitly through the reference.
+      #
+      def trailing_block: (Prism::Node | Prism::Location) -> Reference?
+
+      # Yields leading CommentBlocks that is enclosed in the given node
+      #
+      # Note that `enclosed_blocks` works only after all of the *leading* blocks inside the node is associated.
+      #
+      # Update association status.
+      #
+      def each_enclosed_block: (Prism::Node) { (CommentBlock) -> void } -> void
+                             | (Prism::Node) -> Enumerator[CommentBlock]
+
+      def each_unassociated_block: () { (CommentBlock) -> void } -> void
+                                 | () -> Enumerator[CommentBlock]
+    end
+  end
+end

data/sig/inline_parser.rbs

@@ -0,0 +1,87 @@
+use RBS::AST::Ruby::Declarations
+
+module RBS
+  class InlineParser
+    class Result
+      attr_reader buffer: Buffer
+      attr_reader prism_result: Prism::ParseResult
+      attr_reader declarations: Array[AST::Ruby::Declarations::t]
+      attr_reader diagnostics: Array[Diagnostic::t]
+
+      def initialize: (Buffer, Prism::ParseResult) -> void
+    end
+
+    module Diagnostic
+      class Base
+        attr_reader message: String
+
+        attr_reader location: Location
+
+        def initialize: (Location, String) -> void
+      end
+
+      class NotImplementedYet < Base
+      end
+
+      class NonConstantClassName < Base
+      end
+
+      class NonConstantModuleName < Base
+      end
+
+      class TopLevelMethodDefinition < Base
+      end
+
+      class UnusedInlineAnnotation < Base
+      end
+
+      class AnnotationSyntaxError < Base
+      end
+
+      type t = NotImplementedYet
+             | NonConstantClassName | NonConstantModuleName
+             | TopLevelMethodDefinition
+             | UnusedInlineAnnotation | AnnotationSyntaxError
+    end
+
+    def self.parse: (Buffer, Prism::ParseResult) -> Result
+
+    class Parser < Prism::Visitor
+      type module_context = Declarations::ClassDecl | Declarations::ModuleDecl
+
+      include AST::Ruby::Helpers::ConstantHelper
+
+      include AST::Ruby::Helpers::LocationHelper
+
+      attr_reader comments: CommentAssociation
+
+      attr_reader result: Result
+
+      attr_reader module_nesting: Array[module_context]
+
+      def initialize: (Result) -> void
+
+      def buffer: () -> Buffer
+
+      %a{pure} def current_module: () -> module_context?
+
+      %a{pure} def current_module!: () -> module_context
+
+      def diagnostics: () -> Array[Diagnostic::t]
+
+      def push_module_nesting: [T] (module_context) { () -> T } -> T
+
+      # Returns `true` if the node is a comment block including `@rbs skip` annotation
+      #
+      # Doesn't update the `association` flag if returning `false`.
+      #
+      def skip_node?: (Prism::Node) -> bool
+
+      def insert_declaration: (module_context) -> void
+
+      def report_unused_annotation: (*AST::Ruby::Annotations::t | nil | AST::Ruby::CommentBlock::AnnotationSyntaxError) -> void
+
+      def report_unused_block: (AST::Ruby::CommentBlock) -> void
+    end
+  end
+end

data/sig/location.rbs

@@ -4,14 +4,20 @@ module RBS
   #
   # A location can have _child_ locations.
   #
-  class Location[in RequiredChildKeys, in OptionalChildKeys]
+  class Location[in RequiredChildKeys = untyped, in OptionalChildKeys = untyped]
     # The buffer this location points on.
     attr_reader buffer (): Buffer
 
-    # The index of character the range starts from.
+    # The absolute start index of character the range starts from
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
     attr_reader start_pos (): Integer
 
-    # The index of character the range ends at.
+    # The absolute end index of character the range ends at
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
     attr_reader end_pos (): Integer
 
     def initialize: (Buffer, Integer start_pos, Integer end_pos) -> void
@@ -24,26 +30,37 @@ module RBS
     # Returns the name of the buffer.
     def name: () -> untyped
 
-    # Line of the `start_pos` (1 origin)
+    # The *raw* index of character the range starts from.
+    attr_reader _start_pos (): Integer
+
+    # The *raw* index of character the range ends at.
+    attr_reader _end_pos (): Integer
+
+    # Line of the `start_pos` (1 origin, absolute)
     attr_reader start_line (): Integer
 
-    # Column of the `start_pos` (0 origin)
+    # Column of the `start_pos` (0 origin, absolute)
     attr_reader start_column (): Integer
 
-    # Line of the `end_pos` (1 origin)
+    # Line of the `end_pos` (1 origin, absolute)
     attr_reader end_line (): Integer
 
-    # Column of the `end_pos` (0 origin)
+    # Column of the `end_pos` (0 origin, absolute)
     attr_reader end_column (): Integer
 
+    # The absolute line-column pair of the start position
+    #
     attr_reader start_loc (): Buffer::loc
 
     @start_loc: Buffer::loc?
 
+    # The absolute line-column pair of the end position
+    #
     attr_reader end_loc (): Buffer::loc
 
     @end_loc: Buffer::loc?
 
+    # The absolute range of the start and end position
     attr_reader range (): Range[Integer]
 
     @range: Range[Integer]?
@@ -97,6 +114,14 @@ module RBS
 
     def key?: (Symbol) -> bool
 
+    # Returns the location of the buffer, but the buffer is detached from the parent buffer
+    #
+    def local_location: () -> self
+
+    # Returns the source of `#local_location`
+    # 
+    def local_source: () -> String
+
     private
 
     def _add_required_child: (RequiredChildKeys name, Integer start_pos, Integer end_pos) -> void

data/sig/manifest.yaml

@@ -1,5 +1,6 @@
 dependencies:
   - name: logger
+  - name: pathname
   - name: json
   - name: optparse
   - name: tsort

data/sig/method_builder.rbs

@@ -16,16 +16,19 @@ module RBS
         #
         class Definition
           type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
+                        | AST::Ruby::Members::DefMember
+
+          type overloading_definition = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
 
           type accessibility = RBS::Definition::accessibility
 
           attr_reader name: Symbol
           attr_reader type: instance_type
           attr_reader originals: Array[original]
-          attr_reader overloads: Array[AST::Members::MethodDefinition]
+          attr_reader overloads: Array[overloading_definition]
           attr_reader accessibilities: Array[accessibility]
 
-          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[AST::Members::MethodDefinition], accessibilities: Array[accessibility]) -> void
+          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[overloading_definition], accessibilities: Array[accessibility]) -> void
 
           def original: () -> original?
 
@@ -74,9 +77,9 @@ module RBS
 
       def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Definition::accessibility) -> void
 
-      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Definition::accessibility) -> void
+      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition | AST::Ruby::Members::DefMember, accessibility: Definition::accessibility) -> void
 
-      def each_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
+      def each_rbs_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
 
       def update: (env: Environment, except: _Each[TypeName]) -> MethodBuilder
     end

data/sig/parser.rbs

@@ -68,24 +68,6 @@ module RBS
     #
     def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
 
-    # Parse a list of type parameters and return it
-    #
-    # ```ruby
-    # RBS::Parser.parse_type_params("")                          # => nil
-    # RBS::Parser.parse_type_params("[U, V]")                    # => `[:U, :V]`
-    # RBS::Parser.parse_type_params("[in U, V < Integer]")       # => `[:U, :V]`
-    # ```
-    #
-    # When `module_type_params` is `false`, an error is raised if `unchecked`, `in` or `out` are used.
-    #
-    # ```ruby
-    # RBS::Parser.parse_type_params("[unchecked U]", module_type_params: false)   # => Raises an error
-    # RBS::Parser.parse_type_params("[out U]", module_type_params: false)         # => Raises an error
-    # RBS::Parser.parse_type_params("[in U]", module_type_params: false)          # => Raises an error
-    # ```
-    #
-    def self.parse_type_params: (Buffer | String, ?module_type_params: bool) -> Array[AST::TypeParam]
-
     # Returns the magic comment from the buffer
     #
     def self.magic_comment: (Buffer) -> AST::Directives::ResolveTypeNames?
@@ -100,6 +82,18 @@ module RBS
 
     KEYWORDS: Hash[String, bot]
 
+    # Parse a leading annotation and return it
+    #
+    # Raises an exception if the source text contains a syntax error.
+    #
+    def self.parse_inline_leading_annotation: (Buffer | String, Range[Integer?], ?variables: Array[Symbol]) -> AST::Ruby::Annotations::leading_annotation
+
+    # Parse a leading annotation and return it
+    #
+    # Raises an exception if the source text contains a syntax error.
+    #
+    def self.parse_inline_trailing_annotation: (Buffer | String, Range[Integer?], ?variables: Array[Symbol]) -> AST::Ruby::Annotations::trailing_annotation
+
     private
 
     def self.buffer: (String | Buffer source) -> Buffer
@@ -110,10 +104,12 @@ module RBS
 
     def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
-    def self._parse_type_params: (Buffer, Integer start_pos, Integer end_pos, bool module_type_params) -> Array[AST::TypeParam]
-
     def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
 
+    def self._parse_inline_leading_annotation: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> AST::Ruby::Annotations::leading_annotation
+
+    def self._parse_inline_trailing_annotation: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> AST::Ruby::Annotations::trailing_annotation
+
     class LocatedValue
     end
   end

data/sig/resolver/type_name_resolver.rbs

@@ -8,59 +8,28 @@ module RBS
     class TypeNameResolver
       type query = [TypeName, context]
 
-      def initialize: (Set[TypeName] all_names, Hash[TypeName, [TypeName, context]] aliases) -> void
+      def initialize: (Environment) -> void
 
-      def self.new: %a{deprecated: Use `build` to build TypeNameResolver from Environment} (Environment) -> instance
-                  | (Set[TypeName] all_names, Hash[TypeName, [TypeName, context]] aliases) -> instance
-
-      def self.build: (Environment) -> instance
-
-      # Translates given type name to absolute type name
-      #
+      # Translates given type name to absolute type name.
       # Returns `nil` if cannot find associated type name.
-      # Module names in the type name are normalized.
       #
       def resolve: (TypeName, context: context) -> TypeName?
 
-      # Translates given type name to absolute type name
-      #
-      # Returns `false` if a cycle is detected while resolving aliases.
-      # Returns `nil` if the type name cannot be resolved.
-      #
-      def resolve_namespace: (TypeName, context: context) -> (TypeName | false | nil)
-
       private
 
-      attr_reader all_names: Set[TypeName]
+      attr_reader env: Environment
 
-      attr_reader aliases: Hash[TypeName, [TypeName, context]]
+      attr_reader all_names: Set[TypeName]
 
       attr_reader cache: Hash[query, TypeName?]
 
-      # Returns the type name if it exists in `all_names` (normalized)
-      #
-      def has_type_name?: (TypeName) -> TypeName?
-
-      # Returns the type name if it is an alias (not normalized)
-      #
-      def aliased_name?: (TypeName) -> TypeName?
+      def has_name?: (TypeName) -> TypeName?
 
       def try_cache: (query) { () -> TypeName? } -> TypeName?
 
-      # Translates the head module name in the context and returns an absolute type name
-      #
-      # Returns `nil` if cannot find associated type name.
-      # The returned namespace may be an alias
-      #
-      def resolve_head_namespace: (Symbol, context) -> TypeName?
-
-      # Resolves the type name in the given context
-      #
-      def resolve_type_name: (Symbol, context) -> TypeName?
-
-      def resolve_namespace0: (TypeName, context, Set[TypeName]) -> (TypeName | false | nil)
+      def resolve_in: (Symbol, context) -> TypeName?
 
-      def normalize_namespace: (TypeName, TypeName rhs, context, Set[TypeName]) -> (TypeName | false | nil)
+      def partition: (TypeName) -> [Symbol, TypeName?]
     end
   end
 end

data/sig/source.rbs

@@ -0,0 +1,48 @@
+module RBS
+  module Source
+    type t = RBS | Ruby
+           
+    class RBS
+      attr_reader buffer: Buffer
+
+      attr_reader directives: Array[AST::Directives::t]
+
+      attr_reader declarations: Array[AST::Declarations::t]
+
+      def initialize: (Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]) -> void
+
+      # Enumerates defined type names in the source
+      #
+      # The order is undefined. Deduplicated per source object.
+      #
+      def each_type_name: () { (TypeName) -> void } -> void
+                        | () -> Enumerator[TypeName]
+
+      private def each_declaration_type_name: (Set[TypeName], AST::Declarations::t) { (TypeName) -> void } -> void
+    end
+
+    class Ruby
+      attr_reader buffer: Buffer
+
+      attr_reader prism_result: Prism::ParseResult
+
+      attr_reader declarations: Array[AST::Ruby::Declarations::t]
+
+      attr_reader diagnostics: Array[untyped]
+
+      def initialize: (Buffer, Prism::ParseResult, Array[AST::Ruby::Declarations::t], Array[untyped]) -> void
+
+      def each_type_name: () { (TypeName) -> void } -> void
+                        | () -> Enumerator[TypeName]
+
+      private def each_declaration_type_name: (Set[TypeName], AST::Ruby::Declarations::t) { (TypeName) -> void } -> void
+
+      # Compares the type declaration between `self` and `other`
+      #
+      # The comparison is based on the AST structure.
+      # Differences on Ruby code implementation may be ignored.
+      #
+      def ==: (other: Ruby) -> bool
+    end
+  end
+end

data/sig/types.rbs

@@ -518,10 +518,7 @@ module RBS
 
       attr_reader self_type: t?
 
-      type loc = Location[bot, bot]
-      attr_reader location: loc?
-
-      def initialize: (?location: loc?, type: function, ?self_type: t?, required: boolish) -> void
+      def initialize: (type: function, ?self_type: t?, required: boolish) -> void
 
       def ==: (untyped other) -> bool