rbs 4.0.1 → 4.1.0.pre.1

data/core/kernel.rbs

@@ -182,9 +182,9 @@ module Kernel : BasicObject
   #     c(4)   #=> []
   #     c(5)   #=> nil
   #
-  def self?.caller: (Integer start_or_range, ?Integer length) -> ::Array[String]?
-                  | (::Range[Integer] start_or_range) -> ::Array[String]?
-                  | () -> ::Array[String]
+  def self?.caller: () -> Array[String]
+                  | (int start, ?int? length) -> Array[String]?
+                  | (range[int] range) -> Array[String]?
 
   # <!--
   #   rdoc-file=vm_backtrace.c
@@ -207,9 +207,9 @@ module Kernel : BasicObject
   # Optionally you can pass a range, which will return an array containing the
   # entries within the specified range.
   #
-  def self?.caller_locations: (Integer start_or_range, ?Integer length) -> ::Array[Thread::Backtrace::Location]?
-                            | (::Range[Integer] start_or_range) -> ::Array[Thread::Backtrace::Location]?
-                            | () -> ::Array[Thread::Backtrace::Location]
+  def self?.caller_locations: () -> Array[Thread::Backtrace::Location]
+                            | (int start, ?int? length) -> Array[Thread::Backtrace::Location]?
+                            | (range[int] range) -> Array[Thread::Backtrace::Location]?
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -314,6 +314,16 @@ module Kernel : BasicObject
   #
   def self?.block_given?: () -> bool
 
+  alias self.iterator? self.block_given?
+
+  # <!--
+  #   rdoc-file=vm_eval.c
+  #   - iterator?      -> true or false
+  # -->
+  # Deprecated.  Use block_given? instead.
+  #
+  alias iterator? block_given?
+
   # <!--
   #   rdoc-file=vm_eval.c
   #   - local_variables    -> array
@@ -326,7 +336,7 @@ module Kernel : BasicObject
   #     end
   #     local_variables   #=> [:fred, :i]
   #
-  def self?.local_variables: () -> ::Array[Symbol]
+  def self?.local_variables: () -> Array[Symbol]
 
   # <!--
   #   rdoc-file=random.c
@@ -788,7 +798,7 @@ module Kernel : BasicObject
   #
   # Files that are currently being loaded must not be registered for autoload.
   #
-  def self?.autoload: (interned _module, String filename) -> NilClass
+  def self?.autoload: (interned const, path filename) -> nil
 
   # <!--
   #   rdoc-file=load.c
@@ -812,7 +822,7 @@ module Kernel : BasicObject
   #       autoload?(:B)          #=> "b"
   #     end
   #
-  def self?.autoload?: (interned name) -> String?
+  def self?.autoload?: (interned name, ?boolish inherit) -> String?
 
   # <!--
   #   rdoc-file=proc.c
@@ -1193,7 +1203,7 @@ module Kernel : BasicObject
   #
   #     global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
   #
-  def self?.global_variables: () -> ::Array[Symbol]
+  def self?.global_variables: () -> Array[Symbol]
 
   # <!--
   #   rdoc-file=load.c
@@ -1843,7 +1853,12 @@ module Kernel : BasicObject
   # ----------------|---------------------------------------------
   # <code>'-'</code>|Whether the entities exist and are identical.
   #
-  def self?.test: (String | Integer cmd, String | IO file1, ?String | IO file2) -> (TrueClass | FalseClass | Time | nil | Integer)
+  def self?.test: ('b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'G' | 'k' | 'l' | 'o' | 'O' | 'p' | 'r' | 'R' | 'S' | 'u' | 'w' | 'W' | 'x' | 'X' | 'z' |
+                    98 | 99 | 100 | 101 | 102 | 103 | 71 | 107 | 108 | 111 | 79 | 112 | 114 | 82 | 83 | 117 | 119 | 87 | 120 | 88 | 122, path filepath) -> bool
+                | ('s' | 115, path filepath) -> Integer?
+                | ('A' | 'M' | 'C' | 65 | 77 | 67, path filepath) -> Time
+                | ('<' | '=' | '>' | '-' | 60 | 61 | 62 | 45, path filepath1, path filepath2) -> bool
+                | (String | int cmd, path filepath1, ?path filepath2) -> (bool | Time | Integer | nil)
 
   # <!--
   #   rdoc-file=vm_eval.c

data/core/ruby_vm.rbs

@@ -371,6 +371,46 @@ class RubyVM::InstructionSequence < Object
   # event_symbol] pair.
   #
   def trace_points: () -> Array[untyped]
+
+  # <!--
+  #   rdoc-file=iseq.c
+  #   - of(p1)
+  # -->
+  # Returns the instruction sequence containing the given proc or method.
+  #
+  # For example, using irb:
+  #
+  #     # a proc
+  #     > p = proc { num = 1 + 2 }
+  #     > RubyVM::InstructionSequence.of(p)
+  #     > #=> <RubyVM::InstructionSequence:block in irb_binding@(irb)>
+  #
+  #     # for a method
+  #     > def foo(bar); puts bar; end
+  #     > RubyVM::InstructionSequence.of(method(:foo))
+  #     > #=> <RubyVM::InstructionSequence:foo@(irb)>
+  #
+  # Using ::compile_file:
+  #
+  #     # /tmp/iseq_of.rb
+  #     def hello
+  #       puts "hello, world"
+  #     end
+  #
+  #     $a_global_proc = proc { str = 'a' + 'b' }
+  #
+  #     # in irb
+  #     > require '/tmp/iseq_of.rb'
+  #
+  #     # first the method hello
+  #     > RubyVM::InstructionSequence.of(method(:hello))
+  #     > #=> #<RubyVM::InstructionSequence:0x007fb73d7cb1d0>
+  #
+  #     # then the global proc
+  #     > RubyVM::InstructionSequence.of($a_global_proc)
+  #     > #=> #<RubyVM::InstructionSequence:0x007fb73d7caf78>
+  #
+  def self.of: (Proc | Method | UnboundMethod body) -> RubyVM::InstructionSequence?
 end
 
 # <!-- rdoc-file=ast.rb -->

data/docs/inline.md

@@ -123,10 +123,38 @@ end
 
 This creates the types `::API`, `::API::V1`, and `::API::V1::Resources`.
 
+### `module-self` constraint
+
+The `module-self` constraint declares which classes or modules the module can be mixed into.
+
+```ruby
+# @rbs module-self: _Each[String]
+module Enumerable2
+end
+```
+
+This is equivalent to `module Enumerable2 : _Each[String]` in RBS, meaning `Enumerable2` can only be included in classes that satisfy the `_Each[String]` interface.
+
+Multiple `module-self` constraints can be declared with separate annotations:
+
+```ruby
+# @rbs module-self: _Each[String]
+# @rbs module-self: Comparable
+module StringCollection
+end
+```
+
+You can add a description after `--`:
+
+```ruby
+# @rbs module-self: Minitest::Test -- depending on assertion methods
+module TestHelper
+end
+```
+
 ### Current Limitations
 
 - Generic module definitions are not supported
-- Module self-type constraints are not supported
 
 ## Method Definitions
 

data/docs/rust.md

@@ -0,0 +1,96 @@
+# Rust Crates
+
+RBS provides two Rust crates:
+
+- **`ruby-rbs-sys`** -- Low-level FFI bindings to the RBS C parser
+- **`ruby-rbs`** -- High-level safe Rust API for parsing RBS signatures
+
+Both crates are published to [crates.io](https://crates.io/) and are developed within the `rust/` directory of this repository.
+
+## Vendored RBS Source
+
+The Rust crates depend on the RBS C parser source code (`include/`, `src/`) and configuration (`config.yml`) from this repository. These files are vendored into each crate's `vendor/rbs/` directory, which is managed by Rake tasks and not tracked by git.
+
+The file `rust/rbs_version` records which version of RBS the Rust crates are pinned to.
+
+## Setup
+
+After cloning the repository, set up the vendored source before building the Rust crates:
+
+```bash
+rake rust:rbs:sync       # Uses the pinned version from rust/rbs_version
+```
+
+Then build and test:
+
+```bash
+cd rust
+cargo test
+```
+
+## Rake Tasks
+
+### `rake rust:rbs:sync`
+
+Copies the source files from the pinned version into each crate's `vendor/rbs/`. The copied files are made read-only to prevent accidental edits.
+
+### `rake rust:rbs:pin[VERSION]`
+
+Records a git tag in `rust/rbs_version`. For example:
+
+```bash
+rake rust:rbs:pin[v4.0.3]
+```
+
+### `rake rust:publish:ruby-rbs-sys` / `rake rust:publish:ruby-rbs`
+
+Publishes each crate to crates.io individually. Each task:
+
+1. Verifies `rust/rbs_version` is set
+2. Verifies vendor directories contain real files (not symlinks)
+3. Verifies the git working tree is clean
+4. Creates a release branch and commits the vendor files
+5. Runs a dry-run to check packaging
+6. Publishes the crate
+
+Set `RBS_RUST_PUBLISH_DRY_RUN=1` to only run the dry-run step and skip the actual publish to crates.io. This is used in CI to verify that the crates can be packaged correctly.
+
+### `rake rust:rbs:symlink`
+
+If your development needs unreleased version of RBS source code, use `rake rust:rbs:symlink` to set up symlinks in vendor directories to refer the worktree source code. Changes to the C parser source are immediately reflected in Rust builds.
+
+## Publishing Workflow
+
+1. Pin the RBS version to release against:
+
+   ```bash
+   rake rust:rbs:pin[v4.0.3]
+   ```
+
+2. Sync the vendored source:
+
+   ```bash
+   rake rust:rbs:sync
+   ```
+
+3. Update crate versions in `rust/ruby-rbs-sys/Cargo.toml` and `rust/ruby-rbs/Cargo.toml`.
+
+4. Build and test:
+
+   ```bash
+   cd rust && cargo test
+   ```
+
+5. Commit the version changes and `rust/rbs_version`:
+
+   ```bash
+   git add rust/rbs_version rust/ruby-rbs-sys/Cargo.toml rust/ruby-rbs/Cargo.toml
+   git commit -m "Bump Rust crate versions"
+   ```
+
+6. Publish each crate:
+
+   ```bash
+   rake rust:publish:ruby-rbs-sys
+   rake rust:publish:ruby-rbs
+   ```

data/ext/rbs_extension/ast_translation.c

@@ -947,6 +947,27 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
             &h
         );
     }
+    case RBS_AST_RUBY_ANNOTATIONS_MODULE_SELF_ANNOTATION: {
+        rbs_ast_ruby_annotations_module_self_annotation_t *node = (rbs_ast_ruby_annotations_module_self_annotation_t *) instance;
+
+        VALUE h = rb_hash_new();
+        rb_hash_aset(h, ID2SYM(rb_intern("location")), rbs_location_range_to_ruby_location(ctx, node->base.location));
+        rb_hash_aset(h, ID2SYM(rb_intern("prefix_location")), rbs_location_range_to_ruby_location(ctx, node->prefix_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("keyword_location")), rbs_location_range_to_ruby_location(ctx, node->keyword_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("colon_location")), rbs_location_range_to_ruby_location(ctx, node->colon_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("name")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->name)); // rbs_type_name
+        rb_hash_aset(h, ID2SYM(rb_intern("args")), rbs_node_list_to_ruby_array(ctx, node->args));
+        rb_hash_aset(h, ID2SYM(rb_intern("open_bracket_location")), rbs_location_range_to_ruby_location(ctx, node->open_bracket_location));   // optional
+        rb_hash_aset(h, ID2SYM(rb_intern("close_bracket_location")), rbs_location_range_to_ruby_location(ctx, node->close_bracket_location)); // optional
+        rb_hash_aset(h, ID2SYM(rb_intern("args_comma_locations")), rbs_location_range_list_to_ruby_array(ctx, node->args_comma_locations));
+        rb_hash_aset(h, ID2SYM(rb_intern("comment_location")), rbs_location_range_to_ruby_location(ctx, node->comment_location)); // optional
+
+        return CLASS_NEW_INSTANCE(
+            RBS_AST_Ruby_Annotations_ModuleSelfAnnotation,
+            1,
+            &h
+        );
+    }
     case RBS_AST_RUBY_ANNOTATIONS_NODE_TYPE_ASSERTION: {
         rbs_ast_ruby_annotations_node_type_assertion_t *node = (rbs_ast_ruby_annotations_node_type_assertion_t *) instance;
 

data/ext/rbs_extension/class_constants.c

@@ -54,6 +54,7 @@ VALUE RBS_AST_Ruby_Annotations_DoubleSplatParamTypeAnnotation;
 VALUE RBS_AST_Ruby_Annotations_InstanceVariableAnnotation;
 VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
 VALUE RBS_AST_Ruby_Annotations_ModuleAliasAnnotation;
+VALUE RBS_AST_Ruby_Annotations_ModuleSelfAnnotation;
 VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 VALUE RBS_AST_Ruby_Annotations_ParamTypeAnnotation;
 VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
@@ -147,6 +148,7 @@ void rbs__init_constants(void) {
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_InstanceVariableAnnotation, RBS_AST_Ruby_Annotations, "InstanceVariableAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_MethodTypesAnnotation, RBS_AST_Ruby_Annotations, "MethodTypesAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ModuleAliasAnnotation, RBS_AST_Ruby_Annotations, "ModuleAliasAnnotation");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ModuleSelfAnnotation, RBS_AST_Ruby_Annotations, "ModuleSelfAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_NodeTypeAssertion, RBS_AST_Ruby_Annotations, "NodeTypeAssertion");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ParamTypeAnnotation, RBS_AST_Ruby_Annotations, "ParamTypeAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ReturnTypeAnnotation, RBS_AST_Ruby_Annotations, "ReturnTypeAnnotation");

data/ext/rbs_extension/class_constants.h

@@ -62,6 +62,7 @@ extern VALUE RBS_AST_Ruby_Annotations_DoubleSplatParamTypeAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_InstanceVariableAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_ModuleAliasAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_ModuleSelfAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 extern VALUE RBS_AST_Ruby_Annotations_ParamTypeAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;

data/ext/rbs_extension/extconf.rb

@@ -16,6 +16,7 @@ append_cflags [
   '-Wimplicit-fallthrough',
   '-Wunused-result',
   '-Wc++-compat',
+  '-Wnullable-to-nonnull-conversion',
 ]
 
 if ENV['DEBUG']