rbs 4.0.0.dev.4 → 4.0.0

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/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"]
 }