Use explicit names for RBI and signature parameters

Author: Morriar

lib/tapioca/gem/listeners/methods.rb

@@ -102,7 +102,7 @@ def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public
           sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
 
-            name = if name
+            sig_name = if name
               name.to_s
             else
               # For attr_writer methods, Sorbet signatures have the name
@@ -129,10 +129,11 @@ def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public
             # Sanitize param names, except for anonymous splat, keyword splat,
             # and block parameters. Ruby reflects those as `:*`, `:**`, and `:&`,
             # and Sorbet signatures use the same names to store their types.
-            is_anonymous_parameter = anonymous_parameter_name?(type, name)
-            name = fallback_arg_name unless is_anonymous_parameter || valid_parameter_name?(name)
+            is_anonymous_parameter = anonymous_parameter_name?(type, sig_name)
+            sig_name = fallback_arg_name unless is_anonymous_parameter || valid_parameter_name?(sig_name)
+            param_name = is_anonymous_parameter ? nil : sig_name
 
-            [type, name, is_anonymous_parameter]
+            [type, param_name, sig_name]
           end
 
           rbi_method = RBI::Method.new(
@@ -141,26 +142,26 @@ def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public
             visibility: visibility,
           )
 
-          sanitized_parameters.each do |type, name, is_anonymous_parameter|
+          sanitized_parameters.each do |type, param_name, _sig_name|
             case type
             when :req
-              rbi_method << RBI::ReqParam.new(name)
+              rbi_method << RBI::ReqParam.new(param_name)
             when :opt
-              rbi_method << RBI::OptParam.new(name, "T.unsafe(nil)")
+              rbi_method << RBI::OptParam.new(param_name, "T.unsafe(nil)")
             when :rest
-              rbi_method << RBI::RestParam.new(is_anonymous_parameter ? nil : name)
+              rbi_method << RBI::RestParam.new(param_name)
             when :keyreq
-              rbi_method << RBI::KwParam.new(name)
+              rbi_method << RBI::KwParam.new(param_name)
             when :key
-              rbi_method << RBI::KwOptParam.new(name, "T.unsafe(nil)")
+              rbi_method << RBI::KwOptParam.new(param_name, "T.unsafe(nil)")
             when :keyrest
-              rbi_method << RBI::KwRestParam.new(is_anonymous_parameter ? nil : name)
+              rbi_method << RBI::KwRestParam.new(param_name)
             when :block
-              rbi_method << RBI::BlockParam.new(is_anonymous_parameter ? nil : name)
+              rbi_method << RBI::BlockParam.new(param_name)
             end
           end
 
-          parameters_for_signature = sanitized_parameters.map { |type, name, _is_anonymous_parameter| [type, name] }
+          parameters_for_signature = sanitized_parameters.map { |type, _param_name, sig_name| [type, sig_name] }
           @pipeline.push_method(symbol_name, constant, method, rbi_method, signature, parameters_for_signature)
           tree << rbi_method
         end