rbs 4.0.1.dev.1 → 4.0.1.dev.2

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

@@ -1,47 +0,0 @@
-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

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

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

@@ -1,23 +0,0 @@
-[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

@@ -1,204 +0,0 @@
-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

@@ -1,50 +0,0 @@
-#![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

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

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

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

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

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