rbs 3.9.2 → 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/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

@@ -82,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
@@ -94,6 +106,10 @@ module RBS
 
     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/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