actually use Template:::ProcFromWrapper

Author: HertzDevil

src/bindgen/crystal/pass.cr

@@ -22,18 +22,6 @@ module Bindgen
         end
       end
 
-      def arguments_from_binding(list : Enumerable(Parser::Argument))
-        argument = Argument.new(@db)
-
-        list.map_with_index do |arg, idx|
-          if idx == list.size - 1 && arg.variadic?
-            self.variadic_argument
-          else
-            from_binding(arg, qualified: true).to_argument(argument.name(arg, idx))
-          end
-        end
-      end
-
       # Turns the list of arguments into a list of `Call::Argument`s.
       def arguments_to_wrapper(list : Enumerable(Parser::Argument))
         argument = Argument.new(@db)
@@ -77,25 +65,8 @@ module Bindgen
             is_ref, ptr = reconfigure_pass_type(rules.pass_by, is_ref, ptr)
           end
 
-          # HACK: Since the conversion *template* for function types cannot be a
-          # simple string substitution, we simply build the entire string here,
-          # assuming the result is oblivious to `Util.template`.  Ideally,
-          # *template* should be lifted to a class hierarchy.
           if type.kind.function?
-            func_arg_types = type.template.not_nil!.arguments.dup
-            func_ret_type = func_arg_types.shift
-            func_args = func_arg_types.map_with_index do |type, i|
-              Parser::Argument.new("arg#{i}", type)
-            end
-            builder = CallBuilder::CrystalFromCpp.new(@db)
-            call = builder.build(Parser::Method.build(
-              name: "call",
-              return_type: func_ret_type,
-              arguments: func_args,
-              class_name: "Proc",
-            ), receiver: "_proc_")
-            code = call.body.to_code(call, Graph::Platform::Crystal)
-            template = %[BindgenHelper.wrap_proc(#{code.gsub(/\{(.*)\}/, " do \\1 end ")})]
+            template = Template::ProcFromWrapper.new(type, @db).followed_by(template)
           end
 
           ptr += 1 if is_ref # Translate reference to pointer
@@ -119,17 +90,6 @@ module Bindgen
         "Proc(#{names})"
       end
 
-      # As above, but for Crystal bindings.
-      private def proc_to_binding(type)
-        args = type.template.not_nil!.arguments
-
-        types = args[1..-1]
-        types << args.first
-        names = types.map { |t| to_binding(t, qualified: true).type_name.as(String) }.join(", ")
-
-        "Proc(#{names})"
-      end
-
       # Computes a result for passing *type* to the wrapper.
       def to_wrapper(type : Parser::Type) : Call::Result
         to(type) do |is_ref, ptr, type_name, nilable|