Address PR #697 review feedback

- Rename ParameterKind variants to full names (e.g. Req -> RequiredPositional)
- Merge two let-else bindings into one in rdx_definition_signatures
- Make collect_method_signatures private
- Change Signature#initialize from keyword arguments to positional arguments

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: soutaro

ext/rubydex/signature.c

@@ -16,14 +16,14 @@ VALUE cForwardParameter;
 
 static VALUE parameter_class_for_kind(ParameterKind kind) {
     switch (kind) {
-    case ParameterKind_Req:     return cPositionalParameter;
-    case ParameterKind_Opt:     return cOptionalPositionalParameter;
-    case ParameterKind_Rest:    return cRestPositionalParameter;
-    case ParameterKind_Keyreq:  return cKeywordParameter;
-    case ParameterKind_Key:     return cOptionalKeywordParameter;
-    case ParameterKind_Keyrest: return cRestKeywordParameter;
-    case ParameterKind_Block:   return cBlockParameter;
-    case ParameterKind_Forward: return cForwardParameter;
+    case ParameterKind_RequiredPositional: return cPositionalParameter;
+    case ParameterKind_OptionalPositional: return cOptionalPositionalParameter;
+    case ParameterKind_Rest:               return cRestPositionalParameter;
+    case ParameterKind_RequiredKeyword:    return cKeywordParameter;
+    case ParameterKind_OptionalKeyword:    return cOptionalKeywordParameter;
+    case ParameterKind_RestKeyword:        return cRestKeywordParameter;
+    case ParameterKind_Block:              return cBlockParameter;
+    case ParameterKind_Forward:            return cForwardParameter;
     default: rb_raise(rb_eRuntimeError, "Unknown ParameterKind: %d", kind);
     }
 }
@@ -62,10 +62,8 @@ VALUE rdxi_signatures_to_ruby(SignatureArray *arr, VALUE graph_obj, VALUE defaul
             rb_ary_push(parameters, param);
         }
 
-        VALUE sig_kwargs = rb_hash_new();
-        rb_hash_aset(sig_kwargs, ID2SYM(rb_intern("parameters")), parameters);
-        rb_hash_aset(sig_kwargs, ID2SYM(rb_intern("method_definition")), method_def);
-        VALUE signature = rb_class_new_instance_kw(1, &sig_kwargs, cSignature, RB_PASS_KEYWORDS);
+        VALUE sig_argv[] = {parameters, method_def};
+        VALUE signature = rb_class_new_instance(2, sig_argv, cSignature);
 
         rb_ary_push(signatures, signature);
     }

lib/rubydex/signature.rb

@@ -22,8 +22,8 @@ def initialize(name, location)
     #: MethodDefinition
     attr_reader :method_definition
 
-    #: (parameters: Array[Parameter], method_definition: MethodDefinition) -> void
-    def initialize(parameters:, method_definition:)
+    #: (Array[Parameter], MethodDefinition) -> void
+    def initialize(parameters, method_definition)
       @parameters = parameters
       @method_definition = method_definition
     end

rust/rubydex-sys/src/definition_api.rs

@@ -355,24 +355,24 @@ pub unsafe extern "C" fn rdx_definition_name_location(pointer: GraphPointer, def
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum ParameterKind {
-    Req = 0,
-    Opt = 1,
+    RequiredPositional = 0,
+    OptionalPositional = 1,
     Rest = 2,
-    Keyreq = 3,
-    Key = 4,
-    Keyrest = 5,
+    RequiredKeyword = 3,
+    OptionalKeyword = 4,
+    RestKeyword = 5,
     Block = 6,
     Forward = 7,
 }
 
 fn map_parameter_kind(param: &Parameter) -> ParameterKind {
     match param {
-        Parameter::RequiredPositional(_) | Parameter::Post(_) => ParameterKind::Req,
-        Parameter::OptionalPositional(_) => ParameterKind::Opt,
+        Parameter::RequiredPositional(_) | Parameter::Post(_) => ParameterKind::RequiredPositional,
+        Parameter::OptionalPositional(_) => ParameterKind::OptionalPositional,
         Parameter::RestPositional(_) => ParameterKind::Rest,
-        Parameter::RequiredKeyword(_) => ParameterKind::Keyreq,
-        Parameter::OptionalKeyword(_) => ParameterKind::Key,
-        Parameter::RestKeyword(_) => ParameterKind::Keyrest,
+        Parameter::RequiredKeyword(_) => ParameterKind::RequiredKeyword,
+        Parameter::OptionalKeyword(_) => ParameterKind::OptionalKeyword,
+        Parameter::RestKeyword(_) => ParameterKind::RestKeyword,
         Parameter::Block(_) => ParameterKind::Block,
         Parameter::Forward(_) => ParameterKind::Forward,
     }
@@ -415,11 +415,7 @@ pub struct SignatureArray {
 pub unsafe extern "C" fn rdx_definition_signatures(pointer: GraphPointer, definition_id: u64) -> *mut SignatureArray {
     with_graph(pointer, |graph| {
         let def_id = DefinitionId::new(definition_id);
-        let Some(defn) = graph.definitions().get(&def_id) else {
-            panic!("Definition not found: {definition_id:?}");
-        };
-
-        let Definition::Method(method_def) = defn else {
+        let Some(Definition::Method(method_def)) = graph.definitions().get(&def_id) else {
             return ptr::null_mut();
         };
 
@@ -435,8 +431,8 @@ pub unsafe extern "C" fn rdx_definition_signatures(pointer: GraphPointer, defini
     })
 }
 
-/// Helper: build signature entries from a MethodDefinition and append them to the output vector.
-pub(crate) fn collect_method_signatures(
+/// Helper: build signature entries from a `MethodDefinition` and append them to the output vector.
+fn collect_method_signatures(
     graph: &rubydex::model::graph::Graph,
     method_def: &rubydex::model::definitions::MethodDefinition,
     definition_id: u64,