rbs 4.0.0.dev.5 → 4.0.1.dev.1

data/rust/ruby-rbs/tests/sanity.rs

@@ -0,0 +1,47 @@
+use std::path::Path;
+
+use ruby_rbs::node::parse;
+
+fn collect_rbs_files(dir: &Path) -> Vec<std::path::PathBuf> {
+    let mut files = Vec::new();
+
+    for entry in std::fs::read_dir(dir).unwrap() {
+        let entry = entry.unwrap();
+        let path = entry.path();
+
+        if path.is_dir() {
+            files.extend(collect_rbs_files(&path));
+        } else if path.extension().is_some_and(|ext| ext == "rbs") {
+            files.push(path);
+        }
+    }
+
+    files
+}
+
+#[test]
+fn all_included_rbs_can_be_parsed() {
+    let repo_root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
+    let dirs = [repo_root.join("core"), repo_root.join("stdlib")];
+
+    let mut files: Vec<_> = dirs.iter().flat_map(|d| collect_rbs_files(d)).collect();
+    files.sort();
+    assert!(!files.is_empty());
+
+    let mut failures = Vec::new();
+
+    for file in &files {
+        let content = std::fs::read_to_string(file).unwrap();
+
+        if let Err(e) = parse(content.as_bytes()) {
+            failures.push(format!("{}: {}", file.display(), e));
+        }
+    }
+
+    assert!(
+        failures.is_empty(),
+        "Failed to parse {} RBS file(s):\n{}",
+        failures.len(),
+        failures.join("\n")
+    );
+}

data/rust/ruby-rbs/vendor/rbs/config.yml

@@ -0,0 +1 @@
+../../../../config.yml

data/rust/ruby-rbs-sys/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "ruby-rbs-sys"
+version = "0.2.0"
+edition = "2024"
+license = "BSD-2-Clause"
+description = "Low-level FFI bindings for RBS -- the type signature language for Ruby programs"
+homepage = "https://github.com/ruby/rbs"
+repository = "https://github.com/ruby/rbs.git"
+readme = "../../README.md"
+include = [
+    "src/**/*",
+    "vendor/**/*",
+    "build.rs",
+    "wrapper.h",
+    "Cargo.toml",
+]
+
+[lib]
+doctest = false
+
+[build-dependencies]
+bindgen = "0.72.0"
+cc = "1.2.29"

data/rust/ruby-rbs-sys/build.rs

@@ -0,0 +1,204 @@
+use std::{
+    env,
+    error::Error,
+    fs,
+    path::{Path, PathBuf},
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let vendor_rbs = manifest_dir.join("vendor/rbs");
+    let include = vendor_rbs.join("include");
+    let c_src = vendor_rbs.join("src");
+
+    build(&include, &c_src)?;
+
+    let bindings = generate_bindings(&include)?;
+    write_bindings(&bindings)?;
+
+    Ok(())
+}
+
+fn build(include_dir: &Path, src_dir: &Path) -> Result<(), Box<dyn Error>> {
+    let mut build = cc::Build::new();
+
+    build.include(include_dir);
+
+    // Suppress unused parameter warnings from C code
+    build.flag_if_supported("-Wno-unused-parameter");
+
+    build.files(source_files(src_dir)?);
+    build.try_compile("rbs")?;
+
+    Ok(())
+}
+
+fn source_files<P: AsRef<Path>>(root_dir: P) -> Result<Vec<String>, Box<dyn Error>> {
+    let mut files = Vec::new();
+
+    for entry in fs::read_dir(root_dir.as_ref()).map_err(|e| {
+        format!(
+            "Failed to read source directory {:?}: {e}",
+            root_dir.as_ref()
+        )
+    })? {
+        let entry = entry.map_err(|e| format!("Failed to read directory entry: {e}"))?;
+        let path = entry.path();
+
+        if path.is_file() {
+            let path_str = path
+                .to_str()
+                .ok_or_else(|| format!("Invalid UTF-8 in filename: {path:?}"))?;
+
+            if Path::new(path_str)
+                .extension()
+                .is_some_and(|ext| ext.eq_ignore_ascii_case("c"))
+            {
+                files.push(path_str.to_string());
+            }
+        } else if path.is_dir() {
+            files.extend(source_files(path)?);
+        }
+    }
+
+    Ok(files)
+}
+
+fn generate_bindings(include_path: &Path) -> Result<bindgen::Bindings, Box<dyn Error>> {
+    let bindings = bindgen::Builder::default()
+        .header("wrapper.h")
+        .clang_arg(format!("-I{}", include_path.display()))
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .generate_comments(true)
+        // Core types
+        .allowlist_type("rbs_ast_annotation_t")
+        .allowlist_type("rbs_ast_bool_t")
+        .allowlist_type("rbs_ast_comment_t")
+        .allowlist_type("rbs_ast_declarations_class_alias_t")
+        .allowlist_type("rbs_ast_declarations_class_super_t")
+        .allowlist_type("rbs_ast_declarations_class_t")
+        .allowlist_type("rbs_ast_declarations_constant_t")
+        .allowlist_type("rbs_ast_declarations_global_t")
+        .allowlist_type("rbs_ast_declarations_interface_t")
+        .allowlist_type("rbs_ast_declarations_module_alias_t")
+        .allowlist_type("rbs_ast_declarations_module_self_t")
+        .allowlist_type("rbs_ast_declarations_module_t")
+        .allowlist_type("rbs_ast_declarations_type_alias_t")
+        .allowlist_type("rbs_ast_directives_use_single_clause_t")
+        .allowlist_type("rbs_ast_directives_use_t")
+        .allowlist_type("rbs_ast_directives_use_wildcard_clause_t")
+        .allowlist_type("rbs_ast_integer_t")
+        .allowlist_type("rbs_attr_ivar_name_t")
+        .allowlist_type("rbs_ast_members_alias_t")
+        .allowlist_type("rbs_ast_members_attr_accessor_t")
+        .allowlist_type("rbs_ast_members_attr_reader_t")
+        .allowlist_type("rbs_ast_members_attr_writer_t")
+        .allowlist_type("rbs_ast_members_class_instance_variable_t")
+        .allowlist_type("rbs_ast_members_class_variable_t")
+        .allowlist_type("rbs_ast_members_extend_t")
+        .allowlist_type("rbs_ast_members_include_t")
+        .allowlist_type("rbs_ast_members_instance_variable_t")
+        .allowlist_type("rbs_ast_members_method_definition_overload_t")
+        .allowlist_type("rbs_ast_members_method_definition_t")
+        .allowlist_type("rbs_ast_members_prepend_t")
+        .allowlist_type("rbs_ast_members_private_t")
+        .allowlist_type("rbs_ast_members_public_t")
+        .allowlist_type("rbs_ast_ruby_annotations_class_alias_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_colon_method_type_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_instance_variable_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_method_types_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_module_alias_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_node_type_assertion_t")
+        .allowlist_type("rbs_ast_ruby_annotations_return_type_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_skip_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_type_application_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_block_param_type_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_param_type_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_splat_param_type_annotation_t")
+        .allowlist_type("rbs_ast_ruby_annotations_double_splat_param_type_annotation_t")
+        .allowlist_type("rbs_ast_string_t")
+        .allowlist_type("rbs_ast_symbol_t")
+        .allowlist_type("rbs_ast_type_param_t")
+        .allowlist_type("rbs_encoding_t")
+        .allowlist_type("rbs_encoding_type_t")
+        .allowlist_type("rbs_location_range")
+        .allowlist_type("rbs_location_range_list_t")
+        .allowlist_type("rbs_location_range_list_node_t")
+        .allowlist_type("rbs_method_type_t")
+        .allowlist_type("rbs_namespace_t")
+        .allowlist_type("rbs_node_list_t")
+        .allowlist_type("rbs_signature_t")
+        .allowlist_type("rbs_string_t")
+        .allowlist_type("rbs_type_name_t")
+        .allowlist_type("rbs_types_alias_t")
+        .allowlist_type("rbs_types_bases_any_t")
+        .allowlist_type("rbs_types_bases_bool_t")
+        .allowlist_type("rbs_types_bases_bottom_t")
+        .allowlist_type("rbs_types_bases_class_t")
+        .allowlist_type("rbs_types_bases_instance_t")
+        .allowlist_type("rbs_types_bases_nil_t")
+        .allowlist_type("rbs_types_bases_self_t")
+        .allowlist_type("rbs_types_bases_top_t")
+        .allowlist_type("rbs_types_bases_void_t")
+        .allowlist_type("rbs_types_block_t")
+        .allowlist_type("rbs_types_class_instance_t")
+        .allowlist_type("rbs_types_class_singleton_t")
+        .allowlist_type("rbs_types_function_param_t")
+        .allowlist_type("rbs_types_function_t")
+        .allowlist_type("rbs_types_interface_t")
+        .allowlist_type("rbs_types_intersection_t")
+        .allowlist_type("rbs_types_literal_t")
+        .allowlist_type("rbs_types_optional_t")
+        .allowlist_type("rbs_types_proc_t")
+        .allowlist_type("rbs_types_record_field_type_t")
+        .allowlist_type("rbs_types_record_t")
+        .allowlist_type("rbs_types_tuple_t")
+        .allowlist_type("rbs_types_union_t")
+        .allowlist_type("rbs_types_untyped_function_t")
+        .allowlist_type("rbs_types_variable_t")
+        .constified_enum_module("rbs_alias_kind")
+        .constified_enum_module("rbs_attribute_kind")
+        .constified_enum_module("rbs_attribute_visibility")
+        .constified_enum_module("rbs_encoding_type_t")
+        .constified_enum_module("rbs_attr_ivar_name_tag")
+        .constified_enum_module("rbs_method_definition_kind")
+        .constified_enum_module("rbs_method_definition_visibility")
+        .constified_enum_module("rbs_node_type")
+        .constified_enum_module("rbs_type_param_variance")
+        // Encodings
+        .allowlist_var("rbs_encodings")
+        // Parser functions
+        .allowlist_function("rbs_parse_signature")
+        .allowlist_function("rbs_parser_free")
+        .allowlist_function("rbs_parser_new")
+        // String functions
+        .allowlist_function("rbs_string_new")
+        // Location functions
+        .allowlist_function("rbs_location_range_list_new")
+        .allowlist_function("rbs_location_range_list_append")
+        // Constant pool functions
+        .allowlist_function("rbs_constant_pool_free")
+        .allowlist_function("rbs_constant_pool_id_to_constant")
+        .allowlist_function("rbs_constant_pool_init")
+        .generate()
+        .map_err(|_| "Unable to generate rbs bindings")?;
+
+    Ok(bindings)
+}
+
+fn write_bindings(bindings: &bindgen::Bindings) -> Result<(), Box<dyn Error>> {
+    let out_path = PathBuf::from(
+        env::var("OUT_DIR").map_err(|e| format!("OUT_DIR environment variable not set: {e}"))?,
+    );
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .map_err(|e| {
+            format!(
+                "Failed to write bindings to {:?}: {e}",
+                out_path.join("bindings.rs")
+            )
+        })?;
+
+    Ok(())
+}

data/rust/ruby-rbs-sys/src/lib.rs

@@ -0,0 +1,50 @@
+#![allow(
+    clippy::useless_transmute,
+    clippy::missing_safety_doc,
+    clippy::ptr_offset_with_cast,
+    dead_code,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case
+)]
+pub mod bindings {
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::bindings::*;
+
+    use rbs_encoding_type_t::RBS_ENCODING_UTF_8;
+
+    #[test]
+    fn test_rbs_parser_bindings() {
+        let rbs_code = r#"
+                class User
+                  attr_reader name: String
+                  def initialize: (String) -> void
+                end
+
+                module Authentication
+                  def authenticate: (String, String) -> bool
+                end
+            "#;
+
+        let bytes = rbs_code.as_bytes();
+        let start_ptr = bytes.as_ptr() as *const std::os::raw::c_char;
+        let end_ptr = unsafe { start_ptr.add(bytes.len()) } as *const std::os::raw::c_char;
+
+        let rbs_string = unsafe { rbs_string_new(start_ptr, end_ptr) };
+        let encoding_ptr =
+            unsafe { &rbs_encodings[RBS_ENCODING_UTF_8 as usize] as *const rbs_encoding_t };
+        let parser = unsafe { rbs_parser_new(rbs_string, encoding_ptr, 0, bytes.len() as i32) };
+
+        let mut signature: *mut rbs_signature_t = std::ptr::null_mut();
+        let result = unsafe { rbs_parse_signature(parser, &mut signature) };
+
+        assert!(result, "Failed to parse RBS signature");
+        assert!(!signature.is_null(), "Signature should not be null");
+
+        unsafe { rbs_parser_free(parser) };
+    }
+}

data/rust/ruby-rbs-sys/vendor/rbs/include

@@ -0,0 +1 @@
+../../../../include

data/rust/ruby-rbs-sys/vendor/rbs/src

@@ -0,0 +1 @@
+../../../../src

data/rust/ruby-rbs-sys/wrapper.h

@@ -0,0 +1 @@
+#include "rbs.h"

data/sig/ast/ruby/annotations.rbs

@@ -7,6 +7,10 @@ module RBS
                                 | SkipAnnotation
                                 | ReturnTypeAnnotation
                                 | InstanceVariableAnnotation
+                                | ParamTypeAnnotation
+                                | SplatParamTypeAnnotation
+                                | DoubleSplatParamTypeAnnotation
+                                | BlockParamTypeAnnotation
 
         type trailing_annotation = NodeTypeAssertion
                                  | TypeApplicationAnnotation
@@ -104,9 +108,11 @@ module RBS
         # `@rbs METHOD-TYPEs` annotation in leading comments
         #
         # ```
-        # @rbs () -> void | %a{foo} () -> String
-        # ^^^^                                     -- prefix_location
-        #                 ^                        -- vertical_bar_locations[0]
+        # @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
@@ -115,7 +121,9 @@ module RBS
 
           attr_reader vertical_bar_locations: Array[Location]
 
-          def initialize: (location: Location, prefix_location: Location, overloads: Array[Overload], vertical_bar_locations: Array[Location]) -> void
+          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
 
@@ -228,6 +236,185 @@ module RBS
 
           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

data/sig/ast/ruby/members.rbs

@@ -19,10 +19,28 @@ module RBS
 
         class MethodTypeAnnotation
           class DocStyle
+            type param_type_annotation = Annotations::ParamTypeAnnotation
+                                      | Annotations::SplatParamTypeAnnotation
+                                      | Annotations::DoubleSplatParamTypeAnnotation
+                                      | Annotations::BlockParamTypeAnnotation
+
             attr_accessor return_type_annotation: Annotations::ReturnTypeAnnotation | Annotations::NodeTypeAssertion | nil
 
+            attr_reader required_positionals: Array[Annotations::ParamTypeAnnotation | Symbol]
+            attr_reader optional_positionals: Array[Annotations::ParamTypeAnnotation | Symbol]
+            attr_accessor rest_positionals: Annotations::SplatParamTypeAnnotation | Symbol | true | nil
+            attr_reader trailing_positionals: Array[Annotations::ParamTypeAnnotation | Symbol]
+            attr_reader required_keywords: Hash[Symbol, Annotations::ParamTypeAnnotation | Symbol]
+            attr_reader optional_keywords: Hash[Symbol, Annotations::ParamTypeAnnotation | Symbol]
+            attr_accessor rest_keywords: Annotations::DoubleSplatParamTypeAnnotation | Symbol | true | nil
+            attr_accessor block: Annotations::BlockParamTypeAnnotation | Symbol | true | nil
+
             def initialize: () -> void
 
+            def self.build: (Array[param_type_annotation], Annotations::ReturnTypeAnnotation | Annotations::NodeTypeAssertion | nil, Prism::DefNode) -> [DocStyle, Array[param_type_annotation]]
+
+            def all_param_annotations: () -> Array[param_type_annotation | Symbol | true | nil]
+
             def map_type_name: () { (TypeName) -> TypeName } -> self
 
             def method_type: () -> MethodType
@@ -42,7 +60,7 @@ module RBS
           #
           # 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]) -> [
+          def self.build: (CommentBlock? leading_block, CommentBlock? trailing_block, Array[Symbol], Prism::DefNode) -> [
             MethodTypeAnnotation,
             Array[Annotations::leading_annotation | CommentBlock::AnnotationSyntaxError],
             Annotations::trailing_annotation | CommentBlock::AnnotationSyntaxError | nil
@@ -55,6 +73,8 @@ module RBS
           #
           def overloads: () -> Array[AST::Members::MethodDefinition::Overload]
 
+          def overloading?: () -> bool
+
           def type_fingerprint: () -> untyped
         end
 

data/sig/cli/validate.rbs

@@ -3,14 +3,12 @@ module RBS
     class Validate
       class Errors
         @limit: Integer?
-        @exit_error: boolish
-        @has_syntax_error: bool
         @errors: Array[BaseError]
 
         # The tag that will be thrown in #finish method
         @tag: top
 
-        def initialize: (limit: Integer?, exit_error: boolish) -> void
+        def initialize: (limit: Integer?) -> void
 
         def add: (BaseError) -> void
 
@@ -44,9 +42,6 @@ module RBS
       def validate_constant: () -> void
       def validate_global: () -> void
       def validate_type_alias: () -> void
-      def no_classish_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
-      def no_self_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
-      %a{deprecated} def void_type_context_validator: (::RBS::Types::t | ::RBS::MethodType type, ?bool allowed_here) -> void
     end
   end
 end

data/sig/definition_builder.rbs

@@ -97,6 +97,8 @@ module RBS
     #
     def interface_methods: (Array[Definition::Ancestor::Instance] interface_ancestors) -> interface_methods
 
+    def special_accessibility: (bool, Symbol) -> Definition::accessibility?
+
     def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
 
     def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void

data/sig/errors.rbs

@@ -394,14 +394,6 @@ module RBS
     def location: () -> AST::Declarations::AliasDecl::loc?
   end
 
-  class WillSyntaxError < BaseError
-    include RBS::DetailedMessageable
-
-    def initialize: (String message, location: Location[untyped, untyped]?) -> void
-
-    attr_reader location: Location[untyped, untyped]?
-  end
-
   class TypeParamDefaultReferenceError < BaseError
     include DetailedMessageable
 

data/sig/method_types.rbs

@@ -53,6 +53,6 @@ module RBS
 
     def has_classish_type?: () -> bool
 
-    %a{deprecated} def with_nonreturn_void?: () -> bool
+    def with_nonreturn_void?: () -> bool
   end
 end