rbs 3.9.4 → 4.1.1

data/rbs.gemspec

@@ -30,20 +30,52 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject do |f|
       [
-        %r{^(test|spec|features|bin|steep|benchmark|templates)/},
-        /Gemfile/
+        %r{^(test|spec|features|bin|steep|benchmark|templates|rust|\.vscode)/},
+        /Gemfile/,
       ].any? {|r| f.match(r) }
     end
   end
-  spec.extensions = %w{ext/rbs_extension/extconf.rb}
+
+  # JRuby cannot load the MRI C extension. On JRuby (and in the `java` platform
+  # gem, built with RBS_PLATFORM=java) RBS runs the WebAssembly-backed parser, so
+  # ship the prebuilt parser (built by `rake wasm:build`) and skip the C
+  # extension. The Chicory/ASM jars the runtime needs are NOT shipped in the gem:
+  # they are declared as `jar-dependencies` requirements below and fetched from
+  # Maven Central at install time (see lib/rbs/wasm/jars.rb).
+  building_java_gem = ENV["RBS_PLATFORM"] == "java"
+  on_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+  if building_java_gem || on_jruby
+    # Only stamp the platform when building the release gem; leave it unset for
+    # local development on JRuby so it still matches a `ruby` platform lockfile.
+    spec.platform = "java" if building_java_gem
+    # rbs_parser.wasm is a build artifact (not tracked in git), so add it
+    # explicitly. lib/rbs_jars.rb is committed, so git ls-files already has it.
+    spec.files += Dir.chdir(File.expand_path('..', __FILE__)) do
+      Dir.glob("lib/rbs/wasm/rbs_parser.wasm")
+    end
+
+    # jar-dependencies (bundled with JRuby) downloads these jars from Maven when
+    # the gem is installed, keeping the gem small and avoiding conflicting copies.
+    # Only the top-level artifacts are declared; Maven resolves the rest (runtime,
+    # wasm, asm, ...) transitively. lib/rbs_jars.rb require_jars the full resolved
+    # set at load time.
+    spec.add_dependency "jar-dependencies", ">= 0.1.7"
+    spec.requirements << "jar com.dylibso.chicory:compiler, 1.7.5"
+    spec.requirements << "jar com.dylibso.chicory:wasi, 1.7.5"
+  else
+    spec.extensions = %w{ext/rbs_extension/extconf.rb}
+  end
 
   if false
-    spec.required_ruby_version = ">= 3.3"
+    spec.required_ruby_version = ">= 3.4"
   end
 
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 3.1"
+  spec.required_ruby_version = ">= 3.2"
   spec.add_dependency "logger"
+  spec.add_dependency "prism", ">= 1.6.0"
+  spec.add_dependency "tsort"
 end

data/schema/typeParam.json

@@ -28,9 +28,25 @@
         }
       ]
     },
+    "lower_bound": {
+      "oneOf": [
+        {
+          "$ref": "types.json#/definitions/classInstance"
+        },
+        {
+          "$ref": "types.json#/definitions/classSingleton"
+        },
+        {
+          "$ref": "types.json#/definitions/interface"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "location": {
       "$ref": "location.json"
     }
   },
-  "required": ["name", "variance", "unchecked", "upper_bound", "location"]
+  "required": ["name", "variance", "unchecked", "upper_bound", "lower_bound", "location"]
 }

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/annotate/formatter.rbs

@@ -17,8 +17,8 @@ module RBS
 
       def self.translate: (RDoc::Markup::Document) -> String?
 
-      def self.each_part: (RDoc::Markup::Document | RDoc::Comment | String) { (RDoc::Markup::Document) -> void } -> void
-                        | (RDoc::Markup::Document | RDoc::Comment | String) -> Enumerator[RDoc::Markup::Document, void]
+      def self.each_part: (RDoc::Markup::Document) { (RDoc::Markup::Document) -> void } -> void
+                        | (RDoc::Markup::Document) -> Enumerator[RDoc::Markup::Document, void]
     end
   end
 end

data/sig/annotate/rdoc_annotater.rbs

@@ -8,16 +8,17 @@ module RBS
 
       def initialize: (source: RDocSource) -> void
 
-      def annotate_file: (Pathname, preserve: bool) -> void
+      def annotate_file: (Pathname) -> void
+                       | %a{deprecated: it preserves the format by default} (Pathname, preserve: bool) -> void
 
-      def annotate_decls: (Array[AST::Declarations::t], ?outer: Array[Namespace]) -> void
+      def annotate_decls: (Array[AST::Declarations::t], Rewriter, ?outer: Array[Namespace]) -> void
 
       interface _PathTester
         def test_path: (String) -> bool
       end
 
       interface _WithRDocComment
-        def comment: () -> (RDoc::Markup::Document | RDoc::Comment | String)
+        def comment: () -> (RDoc::Comment | String)
       end
 
       def each_part: (Array[Object & _WithRDocComment], tester: _PathTester) { ([RDoc::Markup::Document, Object & _WithRDocComment]) -> void } -> void
@@ -50,15 +51,15 @@ module RBS
 
       def resolve_doc_source: (Annotations::Copy?, tester: _PathTester) { () -> String? } -> String?
 
-      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, outer: Array[Namespace]) -> void
+      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, Rewriter, outer: Array[Namespace]) -> void
 
-      def annotate_constant: (AST::Declarations::Constant, outer: Array[Namespace]) -> void
+      def annotate_constant: (AST::Declarations::Constant, Rewriter, outer: Array[Namespace]) -> void
 
-      def annotate_method: (TypeName, AST::Members::MethodDefinition) -> void
+      def annotate_method: (TypeName, AST::Members::MethodDefinition, Rewriter) -> void
 
-      def annotate_alias: (TypeName, AST::Members::Alias) -> void
+      def annotate_alias: (TypeName, AST::Members::Alias, Rewriter) -> void
 
-      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor) -> void
+      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor, Rewriter) -> void
 
       def annotations: (_Annotated) -> Annotations
 
@@ -70,10 +71,12 @@ module RBS
       # - If empty string is given as `comment`, it deletes the original comment.
       # - If `nil` is given as `comment`, it keeps the original comment.
       #
-      def replace_comment: (Object & _Commented, String? comment) -> void
+      def replace_comment: (_Commented, String?, Rewriter) -> void
 
       interface _Commented
-        def comment: () -> AST::Comment?
+        %a{pure} def comment: () -> AST::Comment?
+        %a{pure} def location: () -> Location[untyped, untyped]?
+        def annotations: () -> Array[AST::Annotation]
       end
 
       def resolve_name: (TypeName, outer: Array[Namespace]) -> TypeName

data/sig/ast/ruby/annotations.rbs

@@ -0,0 +1,470 @@
+module RBS
+  module AST
+    module Ruby
+      module Annotations
+        type leading_annotation = ColonMethodTypeAnnotation
+                                | MethodTypesAnnotation
+                                | SkipAnnotation
+                                | ReturnTypeAnnotation
+                                | InstanceVariableAnnotation
+                                | ModuleSelfAnnotation
+                                | ParamTypeAnnotation
+                                | SplatParamTypeAnnotation
+                                | DoubleSplatParamTypeAnnotation
+                                | BlockParamTypeAnnotation
+
+        type trailing_annotation = NodeTypeAssertion
+                                 | TypeApplicationAnnotation
+                                 | ClassAliasAnnotation
+                                 | ModuleAliasAnnotation
+
+        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
+
+          # Returns the type fingerprint for this annotation
+          def type_fingerprint: () -> untyped
+        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
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class AliasAnnotation < Base
+          attr_reader keyword_location: Location
+
+          attr_reader type_name_location: Location?
+
+          # The name of the module that will be the target of the alias
+          #
+          # - `nil` if the module/class name is unspecified
+          # - `TypeName` object if the module/class name is specified
+          #
+          attr_reader type_name: TypeName?
+
+          def initialize: (location: Location, prefix_location: Location, keyword_location: Location, type_name: TypeName?, type_name_location: Location?) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+        end
+
+        # `: class-alias` annotation
+        #
+        # ```
+        # : class-alias Foo::Bar
+        # ^                        -- prefix_location
+        #   ^^^^^^^^^^^^           -- keyword_location
+        #                ^^^^^^^^  -- type_name_location
+        # ```
+        #
+        class ClassAliasAnnotation < AliasAnnotation
+          def type_fingerprint: () -> untyped
+        end
+
+        # `: module-alias` annotation
+        #
+        # ```
+        # : module-alias Foo::Bar
+        # ^                        -- prefix_location
+        #   ^^^^^^^^^^^^           -- keyword_location
+        #                ^^^^^^^^  -- type_name_location
+        # ```
+        #
+        class ModuleAliasAnnotation < AliasAnnotation
+          def type_fingerprint: () -> untyped
+        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
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs METHOD-TYPEs` annotation in leading comments
+        #
+        # ```
+        # @rbs () -> void | %a{foo} () -> String | ...
+        # ^^^^                                            -- prefix_location
+        #                 ^                               -- vertical_bar_locations[0]
+        #                                        ^        -- vertical_bar_locations[1]
+        #                                          ^^^    -- dot3_location
+        # ```
+        class MethodTypesAnnotation < Base
+          class Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader overloads: Array[Overload]
+
+          attr_reader vertical_bar_locations: Array[Location]
+
+          attr_reader dot3_location: Location?
+
+          def initialize: (location: Location, prefix_location: Location, overloads: Array[Overload], vertical_bar_locations: Array[Location], dot3_location: Location?) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        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
+
+          def type_fingerprint: () -> untyped
+        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
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `[T1, T2, ...]` annotation in trailing comments
+        #
+        # ```
+        # #[String, Integer]
+        #  ^                     -- prefix_location
+        #         ^              -- comma_locations[0]
+        #                  ^     -- close_bracket_location
+        # ```
+        #
+        class TypeApplicationAnnotation < Base
+          attr_reader type_args: Array[Types::t]
+
+          attr_reader close_bracket_location: Location
+
+          attr_reader comma_locations: Array[Location]
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            type_args: Array[Types::t],
+            close_bracket_location: Location,
+            comma_locations: Array[Location],
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs IVAR-NAME : TYPE` annotation in leading comments
+        #
+        # ```
+        # @rbs @foo : String -- comment
+        # ^^^^                             -- prefix_location
+        #      ^^^^                        -- ivar_name_location
+        #           ^                      -- colon_location
+        #                    ^^^^^^^^^^    -- comment_location
+        # ```
+        class InstanceVariableAnnotation < Base
+          attr_reader ivar_name: Symbol
+
+          attr_reader ivar_name_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            ivar_name: Symbol,
+            ivar_name_location: Location,
+            colon_location: Location,
+            type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs module-self: NAME[ARGS] -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs module-self: _Each[String, Integer] -- comment
+        # ^^^^                                                -- prefix_location
+        #      ^^^^^^^^^^^                                    -- keyword_location
+        #                 ^                                   -- colon_location
+        #                        ^                            -- open_bracket_location
+        #                               ^                     -- args_comma_locations[0]
+        #                                        ^            -- close_bracket_location
+        #                                          ^^^^^^^^^^ -- comment_location
+        # ```
+        #
+        class ModuleSelfAnnotation < Base
+          attr_reader keyword_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader name: TypeName
+
+          attr_reader args: Array[Types::t]
+
+          attr_reader open_bracket_location: Location?
+
+          attr_reader close_bracket_location: Location?
+
+          attr_reader args_comma_locations: Array[Location]
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            keyword_location: Location,
+            colon_location: Location,
+            name: TypeName,
+            args: Array[Types::t],
+            open_bracket_location: Location?,
+            close_bracket_location: Location?,
+            args_comma_locations: Array[Location],
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class ParamTypeAnnotation < Base
+          attr_reader name_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader param_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            name_location: Location,
+            colon_location: Location,
+            param_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure}
+          def name: () -> Symbol
+        end
+
+        # `@rbs *name: Type -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs *a: String -- comment
+        # ^^^^                         -- prefix_location
+        #      ^                       -- star_location
+        #       ^                      -- name_location
+        #        ^                     -- colon_location
+        #                 ^^^^^^^^^^   -- comment_location
+        # ```
+        #
+        # ```
+        # @rbs *: String
+        # ^^^^             -- prefix_location
+        #      ^           -- star_location
+        #       ^          -- colon_location
+        # ```
+        #
+        class SplatParamTypeAnnotation < Base
+          attr_reader star_location: Location
+
+          attr_reader name_location: Location?
+
+          attr_reader colon_location: Location
+
+          attr_reader param_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            star_location: Location,
+            name_location: Location?,
+            colon_location: Location,
+            param_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure}
+          def name: () -> Symbol?
+        end
+
+        # `@rbs **name: Type -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs **b: bool -- comment
+        # ^^^^                        -- prefix_location
+        #      ^^                     -- star2_location
+        #        ^                    -- name_location
+        #         ^                   -- colon_location
+        #                 ^^^^^^^^^^  -- comment_location
+        # ```
+        #
+        # ```
+        # @rbs **: bool
+        # ^^^^            -- prefix_location
+        #      ^^         -- star2_location
+        #        ^        -- colon_location
+        # ```
+        #
+        class DoubleSplatParamTypeAnnotation < Base
+          attr_reader star2_location: Location
+
+          attr_reader name_location: Location?
+
+          attr_reader colon_location: Location
+
+          attr_reader param_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            star2_location: Location,
+            name_location: Location?,
+            colon_location: Location,
+            param_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure}
+          def name: () -> Symbol?
+        end
+
+        # `@rbs &name: TYPE -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs &block: () -> void -- comment
+        # ^^^^                               -- prefix_location
+        #      ^                             -- ampersand_location
+        #       ^^^^^                        -- name_location
+        #            ^                       -- colon_location
+        #              ^^^^^^^^^^            -- type_location
+        #                         ^^^^^^^^^^ -- comment_location
+        # ```
+        #
+        # ```
+        # @rbs &: ? () -> void
+        # ^^^^                 -- prefix_location
+        #      ^               -- ampersand_location
+        #       ^              -- colon_location
+        #         ^            -- question_location
+        #           ^^^^^^^^^^ -- type_location
+        # ```
+        #
+        class BlockParamTypeAnnotation < Base
+          attr_reader ampersand_location: Location
+
+          attr_reader name_location: Location?
+
+          attr_reader colon_location: Location
+
+          attr_reader type_location: Location
+
+          attr_reader type: Types::function
+
+          attr_reader question_location: Location?
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            ampersand_location: Location,
+            name_location: Location?,
+            colon_location: Location,
+            question_location: Location?,
+            type_location: Location,
+            type: Types::function,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure} def name: () -> Symbol?
+
+          def optional?: () -> bool
+
+          def required?: () -> bool
+        end
+      end
+    end
+  end
+end