qt 0.1.9 → 0.2.1

data/scripts/generate_bridge.rb

@@ -35,6 +35,7 @@ def build_qapplication_spec(ast)
     constructor: { parent: false, mode: :qapplication },
     class_methods: class_methods,
     methods: instance_methods,
+    auto_methods: :all,
     validate: { constructors: ['QApplication'], methods: ['exec'] }
   }
 end
@@ -66,8 +67,6 @@ def next_trace_base(fetch_bases, cur, visited)
 end
 
 def trace_generated_super_chain(fetch_bases, known_qt, qt_class, super_qt_by_qt)
-  return if qt_class == 'QApplication'
-
   visited = {}
   prev = cur = qt_class
   loop do
@@ -154,13 +153,13 @@ def find_getter_decl(ast, qt_class, property)
     parsed = parse_method_signature(decl)
     next false unless parsed && parsed[:params].empty?
 
-    map_cpp_return_type(parsed[:return_type], ast: ast)
+    map_cpp_return_type(parsed[:return_type], ast: ast, qt_class: qt_class)
   end
 end
 
 def build_property_getter_method(ast, getter_decl, property)
   parsed_getter = parse_method_signature(getter_decl)
-  ret_info = map_cpp_return_type(parsed_getter[:return_type], ast: ast)
+  ret_info = map_cpp_return_type(parsed_getter[:return_type], ast: ast, qt_class: getter_decl['__owner_class'])
   return nil unless ret_info
 
   getter = {
@@ -250,7 +249,9 @@ def arg_expr(arg)
   when :qicon_ref then "*static_cast<QIcon*>(#{arg[:name]})"
   when :qany_string_view then "QAnyStringView(as_qstring(#{arg[:name]}))"
   when :qvariant_from_utf8 then "qvariant_from_bridge_value(#{arg[:name]})"
+  when :qint_list_from_variant then "QtRubyRuntime::qint_list_from_variant(qvariant_from_bridge_value(#{arg[:name]}))"
   when :alignment then "static_cast<Qt::Alignment>(#{arg[:name]})"
+  when :qt_value_ref then "*static_cast<#{arg[:value_class]}*>(#{arg[:name]})"
   when String then "static_cast<#{arg[:cast]}>(#{arg[:name]})"
   else
     arg[:name]
@@ -306,26 +307,27 @@ end
 
 def generate_cpp_constructor(lines, spec)
   name = ctor_function_name(spec)
+  qt_class = spec[:virtual_adapter] ? generated_virtual_subclass_name(spec) : spec[:qt_class]
 
   if spec[:constructor][:mode] == :qapplication
     emit_cpp_qapplication_constructor(lines, name)
     return
   end
   if spec[:constructor][:mode] == :string_path
-    emit_cpp_string_path_constructor(lines, name, spec[:qt_class], spec[:constructor][:arg_cast])
+    emit_cpp_string_path_constructor(lines, name, qt_class, spec[:constructor][:arg_cast])
     return
   end
   if spec[:constructor][:mode] == :keysequence_parent
-    emit_cpp_keysequence_parent_constructor(lines, name, spec)
+    emit_cpp_keysequence_parent_constructor(lines, name, spec.merge(qt_class: qt_class))
     return
   end
 
   unless spec[:constructor][:parent]
-    emit_cpp_default_constructor(lines, name, spec[:qt_class])
+    emit_cpp_default_constructor(lines, name, qt_class)
     return
   end
 
-  emit_cpp_parent_constructor(lines, name, spec)
+  emit_cpp_parent_constructor(lines, name, spec.merge(qt_class: qt_class))
 end
 
 def generate_cpp_delete(lines)
@@ -335,8 +337,18 @@ def generate_cpp_delete(lines)
   lines << '}'
 end
 
+def generate_cpp_qt_value_deletes(lines, specs, free_function_specs)
+  value_wrapper_classes(specs, free_function_specs: free_function_specs).each do |qt_class|
+    lines << "extern \"C\" void #{qt_value_delete_function_name(qt_class)}(void* handle) {"
+    lines << "  delete static_cast<#{qt_class}*>(handle);"
+    lines << '}'
+    lines << ''
+  end
+end
+
 def cpp_method_signature(method)
-  ['void* handle'] + method[:args].map { |arg| "#{ffi_to_cpp_type(arg[:ffi])} #{arg[:name]}" }
+  ['void* handle'] + (method[:dispatch] ? ['int argc'] : []) +
+    method[:args].map { |arg| "#{ffi_to_cpp_type(arg[:ffi])} #{arg[:name]}" }
 end
 
 def cpp_null_handle_return(method)
@@ -358,19 +370,37 @@ end
 
 def cpp_method_invocation(method)
   call_args = method[:args].map { |arg| arg_expr(arg) }.join(', ')
-  "self_obj->#{method[:qt_name]}(#{call_args})"
+  target = method[:static] ? "#{method[:owner_class]}::#{method[:qt_name]}" : "self_obj->#{method[:qt_name]}"
+  "#{target}(#{call_args})"
 end
 
 def generate_cpp_method(lines, spec, method)
   fn = method_function_name(spec, method)
   ret = ffi_return_to_cpp(method[:ffi_return])
   lines << "extern \"C\" #{ret} #{fn}(#{cpp_method_signature(method).join(', ')}) {"
-  lines << '  if (!handle) {'
-  lines << cpp_null_handle_return(method)
-  lines << '  }'
+  unless method[:static]
+    lines << '  if (!handle) {'
+    lines << cpp_null_handle_return(method)
+    lines << '  }'
+  end
   lines << ''
-  lines << "  auto* self_obj = static_cast<#{spec[:qt_class]}*>(handle);"
-  emit_cpp_method_return(lines, method, cpp_method_invocation(method))
+  lines << "  auto* self_obj = static_cast<#{spec[:qt_class]}*>(handle);" unless method[:static]
+  if method[:dispatch]
+    lines << '  switch (argc) {'
+    (method[:required_arg_count]..method[:args].length).each do |arg_count|
+      selected = method.merge(args: method[:args].take(arg_count))
+      lines << "    case #{arg_count}: {"
+      emit_cpp_method_return(lines, selected, cpp_method_invocation(selected))
+      lines << '      break;' if method[:ffi_return] == :void
+      lines << '    }'
+    end
+    lines << '    default:'
+    lines << cpp_null_handle_return(method).sub(/^    /, '      ')
+    lines << '  }'
+    lines << cpp_null_handle_return(method) if method[:ffi_return] != :void
+  else
+    emit_cpp_method_return(lines, method, cpp_method_invocation(method))
+  end
   lines << '}'
 end
 
@@ -381,11 +411,13 @@ def generate_cpp_bridge(specs, free_function_specs)
 
   specs.each { |spec| append_cpp_spec_methods(lines, spec) }
 
+  generate_cpp_qt_value_deletes(lines, specs, free_function_specs)
   generate_cpp_delete(lines)
   "#{lines.join("\n")}\n"
 end
 
 def append_cpp_spec_methods(lines, spec)
+  generate_cpp_virtual_adapter(lines, spec) if spec[:virtual_adapter]
   unless spec[:constructor][:mode] == :wrap_only
     generate_cpp_constructor(lines, spec)
     lines << ''
@@ -407,6 +439,8 @@ def cpp_bridge_prelude
     #include <QAnyStringView>
     #include <QIcon>
     #include <QJsonDocument>
+    #include <QJsonArray>
+    #include <QJsonObject>
     #include <QJsonParseError>
     #include <QDateTime>
     #include <QDate>
@@ -553,6 +587,14 @@ def cpp_bridge_prelude
       return QStringLiteral("qtv:str:") + QString::fromUtf8(fallback);
     }
 
+    QString qstring_list_to_bridge_string(const QStringList& value) {
+      QJsonArray array;
+      for (const QString& item : value) {
+        array.append(item);
+      }
+      return QString::fromUtf8(QJsonDocument(array).toJson(QJsonDocument::Compact));
+    }
+
     QString qobject_list_to_bridge_string(const QObjectList& value) {
       QJsonArray array;
       for (QObject* object : value) {
@@ -640,6 +682,7 @@ def optional_arg_replacement(arg, safe)
   when :bool then "(#{safe}.nil? ? false : #{safe})"
   when :pointer then safe
   when :string
+    return "(#{safe}.nil? ? Qt::VariantCodec.encode([]) : Qt::VariantCodec.encode(#{safe}))" if arg[:cast] == :qint_list_from_variant
     return "(#{safe}.nil? ? '' : Qt::VariantCodec.encode(#{safe}))" if arg[:cast] == :qvariant_from_utf8
     return "(#{safe}.nil? ? '' : Qt::DateTimeCodec.encode_qdatetime(#{safe}))" if arg[:cast] == :qdatetime_from_utf8
     return "(#{safe}.nil? ? '' : Qt::DateTimeCodec.encode_qdate(#{safe}))" if arg[:cast] == :qdate_from_utf8
@@ -653,8 +696,13 @@ def optional_arg_replacement(arg, safe)
 end
 
 def ruby_arg_call_value(arg, safe, optional:)
+  if arg[:cast] == :qt_value_ref
+    return optional ? "(#{safe}.nil? ? nil : #{safe}.handle)" : "#{safe}.handle"
+  end
+
   return "Qt::StringCodec.to_qt_text(#{safe})" if text_bridge_arg?(arg) && !optional
   return "Qt::VariantCodec.encode(#{safe})" if arg[:cast] == :qvariant_from_utf8 && !optional
+  return "Qt::VariantCodec.encode(#{safe})" if arg[:cast] == :qint_list_from_variant && !optional
   return "Qt::DateTimeCodec.encode_qdatetime(#{safe})" if arg[:cast] == :qdatetime_from_utf8 && !optional
   return "Qt::DateTimeCodec.encode_qdate(#{safe})" if arg[:cast] == :qdate_from_utf8 && !optional
   return "Qt::DateTimeCodec.encode_qtime(#{safe})" if arg[:cast] == :qtime_from_utf8 && !optional
@@ -687,20 +735,26 @@ def append_ruby_native_call_method(lines, method:, native_call:, indent:)
   method_body = ruby_native_method_body(method, rewritten_native_call)
 
   lines << "#{indent}def #{ruby_name}(#{ruby_args})"
-  lines << "#{indent}  #{method_body}"
+  lines << "#{indent}  Qt::VirtualMethodRuntime.after_native_call(#{method_body})"
   lines << "#{indent}end"
   lines << "#{indent}alias_method :#{snake_alias}, :#{ruby_name}" if snake_alias != ruby_name
 end
 
 def ruby_native_method_body(method, rewritten_native_call)
   return "Qt::StringCodec.from_qt_text(#{rewritten_native_call})" if method[:return_cast] == :qstring_to_utf8
+  return "JSON.parse(Qt::StringCodec.from_qt_text(#{rewritten_native_call}))" if method[:return_cast] == :qstring_list_to_json
   if method[:return_cast] == :qobject_list_to_wrapped_array
     return "Qt::ObjectListCodec.decode(#{rewritten_native_call}, '#{method[:object_list_class]}')"
   end
   return "Qt::VariantCodec.decode(#{rewritten_native_call})" if method[:return_cast] == :qvariant_to_utf8
+  return "Qt::VariantCodec.decode(#{rewritten_native_call})" if method[:return_cast] == :qint_list_to_variant
   return "Qt::DateTimeCodec.decode_qdatetime(#{rewritten_native_call})" if method[:return_cast] == :qdatetime_to_utf8
   return "Qt::DateTimeCodec.decode_qdate(#{rewritten_native_call})" if method[:return_cast] == :qdate_to_utf8
   return "Qt::DateTimeCodec.decode_qtime(#{rewritten_native_call})" if method[:return_cast] == :qtime_to_utf8
+  if method[:return_cast] == :qt_value_copy
+    delete_method = qt_value_delete_function_name(method[:value_class])
+    return "Qt::ValueWrapper.wrap(#{rewritten_native_call}, '#{method[:value_class]}', :#{delete_method})"
+  end
   return "Qt::ObjectWrapper.wrap(#{rewritten_native_call}, '#{method[:pointer_class]}')" if method[:pointer_class]
 
   rewritten_native_call
@@ -765,6 +819,8 @@ def append_widget_initializer(lines, spec:, widget_root:, indent:)
     append_default_widget_initializer(lines, spec, indent)
   end
 
+  lines << "#{indent}  Qt::VirtualMethodRuntime.attach(self)" if spec[:virtual_adapter]
+
   lines << "#{indent}  yield self if block_given?"
   lines << "#{indent}end"
 end
@@ -777,22 +833,32 @@ end
 
 def append_parent_widget_initializer(lines, spec, widget_root, indent)
   lines << "#{indent}def initialize(parent = nil)"
+  append_virtual_runtime_install(lines, spec, indent)
   lines << "#{indent}  @handle = Native.#{spec[:prefix]}_new(parent&.handle)"
   append_parent_registration_logic(lines, spec, indent)
 end
 
 def append_default_widget_initializer(lines, spec, indent)
   lines << "#{indent}def initialize(_argc = 0, _argv = [])"
+  append_virtual_runtime_install(lines, spec, indent)
   lines << "#{indent}  @handle = Native.#{spec[:prefix]}_new"
 end
 
 def append_string_path_initializer(lines, spec, indent)
   lines << "#{indent}def initialize(path = nil)"
+  append_virtual_runtime_install(lines, spec, indent)
   lines << "#{indent}  @handle = Native.#{spec[:prefix]}_new(Qt::StringCodec.to_qt_text(path))"
 end
 
+def append_virtual_runtime_install(lines, spec, indent)
+  return unless spec[:virtual_adapter]
+
+  lines << "#{indent}  Qt::VirtualMethodRuntime.ensure_installed!"
+end
+
 def append_keysequence_parent_initializer(lines, spec, widget_root, indent)
   lines << "#{indent}def initialize(key = nil, parent = nil)"
+  append_virtual_runtime_install(lines, spec, indent)
   lines << "#{indent}  if parent.nil? && (key.nil? || key.respond_to?(:handle))"
   lines << "#{indent}    parent = key"
   lines << "#{indent}    key = nil"
@@ -810,8 +876,9 @@ def append_parent_registration_logic(lines, spec, indent)
   end
 end
 
-def append_ruby_qapplication_prelude(lines, spec, metadata)
-  lines << '  class QApplication'
+def append_ruby_qapplication_prelude(lines, spec, metadata, super_ruby)
+  superclass = super_ruby ? " < #{super_ruby}" : ''
+  lines << "  class QApplication#{superclass}"
   append_ruby_class_api_constants(lines, qt_class: spec[:qt_class], metadata: metadata, indent: '    ')
   lines << ''
   lines << '    attr_reader :handle'
@@ -831,7 +898,7 @@ def append_ruby_qapplication_singleton_accessors(lines)
   lines << '      end'
 end
 
-def generate_ruby_qapplication(lines, spec)
+def generate_ruby_qapplication(lines, spec, super_ruby:)
   metadata = ruby_api_metadata(spec[:methods])
   metadata[:singleton_setter_aliases] = Array(spec[:class_methods]).each_with_object({}) do |method, aliases|
     aliases.merge!(setter_alias_specs(method))
@@ -841,7 +908,8 @@ def generate_ruby_qapplication(lines, spec)
     metadata[:singleton_setter_aliases]
   )
 
-  append_ruby_qapplication_prelude(lines, spec, metadata)
+  append_ruby_qapplication_prelude(lines, spec, metadata, super_ruby)
+  append_ruby_widget_methods(lines, spec.merge(methods: spec[:methods].reject { |method| method[:qt_name] == 'exec' }))
   append_ruby_qapplication_singleton_accessors(lines)
 
   Array(spec[:class_methods]).each { |method| append_ruby_qapplication_class_method(lines, method) }
@@ -893,12 +961,18 @@ end
 
 def qapplication_class_method_body(method, native_call)
   return "        Qt::StringCodec.from_qt_text(#{native_call})" if method[:return_cast] == :qstring_to_utf8
+  return "        JSON.parse(Qt::StringCodec.from_qt_text(#{native_call}))" if method[:return_cast] == :qstring_list_to_json
   if method[:return_cast] == :qobject_list_to_wrapped_array
     return "        Qt::ObjectListCodec.decode(#{native_call}, '#{method[:object_list_class]}')"
   end
   return "        Qt::DateTimeCodec.decode_qdatetime(#{native_call})" if method[:return_cast] == :qdatetime_to_utf8
   return "        Qt::DateTimeCodec.decode_qdate(#{native_call})" if method[:return_cast] == :qdate_to_utf8
   return "        Qt::DateTimeCodec.decode_qtime(#{native_call})" if method[:return_cast] == :qtime_to_utf8
+  return "        Qt::VariantCodec.decode(#{native_call})" if method[:return_cast] == :qint_list_to_variant
+  if method[:return_cast] == :qt_value_copy
+    delete_method = qt_value_delete_function_name(method[:value_class])
+    return "        Qt::ValueWrapper.wrap(#{native_call}, '#{method[:value_class]}', :#{delete_method})"
+  end
   return "        Qt::ObjectWrapper.wrap(#{native_call}, '#{method[:pointer_class]}')" if method[:pointer_class]
 
   "        #{native_call}"
@@ -918,26 +992,303 @@ def generate_ruby_widget_class_header(lines, spec, metadata:, super_ruby:, class
 end
 
 def append_ruby_widget_methods(lines, spec)
-  spec[:methods].each do |method|
-    call_args = ['@handle'] + method[:args].map { |arg| arg[:name] }
-    native_name = method_function_name(spec, method).delete_prefix('qt_ruby_')
-    native_call = "Native.#{native_name}(#{call_args.join(', ')})"
-    append_ruby_native_call_method(lines, method: method, native_call: native_call, indent: '    ')
-    append_ruby_property_writer(lines, method: method, indent: '    ')
+  instance_groups = spec[:methods].reject { |method| method[:static] }.group_by { |method| method[:ruby_name] }
+  instance_groups.each_value do |methods|
+    if methods.one? && !methods.first[:dispatch]
+      method = methods.first
+      call_args = ['@handle'] + method[:args].map { |arg| arg[:name] }
+      native_name = method_function_name(spec, method).delete_prefix('qt_ruby_')
+      append_ruby_native_call_method(
+        lines,
+        method: method,
+        native_call: "Native.#{native_name}(#{call_args.join(', ')})",
+        indent: '    '
+      )
+      append_ruby_property_writer(lines, method: method, indent: '    ')
+    else
+      append_ruby_overload_dispatcher(lines, methods, spec: spec, target: :instance, indent: '    ')
+    end
+    lines << ''
+  end
+
+  static_groups = spec[:methods].select { |method| method[:static] }.group_by { |method| method[:ruby_name] }
+  return if static_groups.empty?
+
+  lines << '    class << self'
+  static_groups.each_value do |methods|
+    if methods.one? && !methods.first[:dispatch]
+      method = methods.first
+      native_name = method_function_name(spec, method).delete_prefix('qt_ruby_')
+      append_ruby_native_call_method(
+        lines,
+        method: method,
+        native_call: "Native.#{native_name}(nil, #{method[:args].map { |arg| arg[:name] }.join(', ')})",
+        indent: '      '
+      )
+    else
+      append_ruby_overload_dispatcher(lines, methods, spec: spec, target: :class, indent: '      ')
+    end
     lines << ''
   end
+  lines << '    end'
+  lines << ''
+end
+
+def append_ruby_overload_dispatcher(lines, methods, spec:, target:, indent:)
+  first = methods.first
+  ruby_name = ruby_safe_method_name(first[:ruby_name])
+  snake_alias = to_snake(ruby_name)
+  max_args = methods.map { |method| method[:args].length }.max
+  min_required = methods.map { |method| method[:required_arg_count] }.min
+  arg_names = (1..max_args).map { |index| "qt_arg#{index}" }
+  signature = arg_names.each_with_index.map do |arg_name, index|
+    index < min_required ? arg_name : "#{arg_name} = Qt::GeneratedOverloadRuntime::OMITTED"
+  end.join(', ')
+
+  lines << "#{indent}def #{ruby_name}(#{signature})"
+  lines << "#{indent}  args = [#{arg_names.join(', ')}]"
+  lines << "#{indent}  args.pop while args.last.equal?(Qt::GeneratedOverloadRuntime::OMITTED)"
+
+  methods.sort_by { |method| [-method[:args].count { |arg| overload_arg_specificity(arg).positive? }, -method[:required_arg_count], method[:args].length] }
+         .each do |method|
+    predicates = [
+      "args.length >= #{method[:required_arg_count]}",
+      "args.length <= #{method[:args].length}"
+    ]
+    method[:args].each_with_index do |arg, index|
+      predicates << overload_arg_predicate(arg, "args[#{index}]", optional: index >= method[:required_arg_count])
+    end
+    lines << "#{indent}  if #{predicates.join(' && ')}"
+
+    arg_map = ruby_arg_name_map(method[:args])
+    method[:args].each_with_index do |arg, index|
+      lines << "#{indent}    #{arg_map[arg[:name]]} = args[#{index}]"
+    end
+    native_name = method_function_name(spec, method).delete_prefix('qt_ruby_')
+    native_args = [target == :instance ? '@handle' : 'nil']
+    native_args << 'args.length' if method[:dispatch]
+    native_args.concat(method[:args].map { |arg| arg_map[arg[:name]] })
+    native_call = "Native.#{native_name}(#{native_args.join(', ')})"
+    required_arg_count = method.fetch(:required_arg_count, method[:args].length)
+    rewritten_native_call = rewrite_native_call_args(native_call, method, arg_map, required_arg_count)
+    lines << "#{indent}    return Qt::VirtualMethodRuntime.after_native_call(#{ruby_native_method_body(method, rewritten_native_call)})"
+    lines << "#{indent}  end"
+  end
+
+  lines << "#{indent}  raise ArgumentError, \"no matching overload for #{ruby_name} (given \" + args.length.to_s + \" arguments)\""
+  lines << "#{indent}end"
+  lines << "#{indent}alias_method :#{snake_alias}, :#{ruby_name}" if snake_alias != ruby_name
+end
+
+def overload_arg_specificity(arg)
+  return 3 if arg[:cast] == :qt_value_ref || arg[:cast] == :qicon_ref
+  return 2 if arg[:cast].is_a?(String) && arg[:cast].end_with?('*')
+
+  0
+end
+
+def overload_arg_predicate(arg, expression, optional:)
+  prefix = optional ? "(#{expression}.nil? || " : ''
+  suffix = optional ? ')' : ''
+  predicate =
+    if arg[:cast] == :qt_value_ref || arg[:cast] == :qicon_ref
+      class_name = arg[:value_class] || ('QIcon' if arg[:cast] == :qicon_ref)
+      class_name ? "#{expression}.is_a?(Qt::#{class_name})" : "#{expression}.respond_to?(:handle)"
+    elsif arg[:cast].is_a?(String) && arg[:cast].end_with?('*')
+      class_name = arg[:cast].delete_suffix('*').split('::').last
+      if class_name.match?(/\AQ[A-Z]\w*\z/)
+        "#{expression}.is_a?(Qt::#{class_name})"
+      else
+        "#{expression}.respond_to?(:handle)"
+      end
+    else
+      case arg[:ffi]
+      when :string then "#{expression}.is_a?(String) || #{expression}.respond_to?(:to_str)"
+      when :int then "#{expression}.is_a?(Integer)"
+      when :bool then "#{expression} == true || #{expression} == false"
+      when :pointer then "#{expression}.nil? || #{expression}.respond_to?(:handle)"
+      else 'true'
+      end
+    end
+  "#{prefix}(#{predicate})#{suffix}"
 end
 
 def assign_unique_native_method_names(specs)
   used = Set.new
   specs.map do |spec|
-    methods = spec[:methods].map do |method|
+    method_groups = spec[:methods].group_by { |method| method[:ruby_name] }
+    methods = spec[:methods].map do |original|
+      method = original.merge(dispatch: method_groups[original[:ruby_name]].length > 1 ||
+                              original.fetch(:required_arg_count, original[:args].length) < original[:args].length)
       assign_unique_native_method_name(spec, method, used)
     end
     spec.merge(methods: methods)
   end
 end
 
+def virtual_wire_argument(arg)
+  return { kind: :integer } if arg[:ffi] == :int
+  return { kind: :boolean } if arg[:ffi] == :bool
+  return { kind: :string } if arg[:ffi] == :string && arg[:cast] == :qstring
+  return { kind: :value, qt_class: arg[:value_class] } if arg[:cast] == :qt_value_ref
+  return { kind: :value, qt_class: 'QIcon' } if arg[:cast] == :qicon_ref
+
+  if arg[:ffi] == :pointer && arg[:cast].is_a?(String) && arg[:cast].end_with?('*')
+    qt_class = arg[:cast].delete_suffix('*').split('::').last
+    return { kind: :pointer, qt_class: qt_class } if qt_class.match?(/\AQ[A-Z]\w*\z/)
+  end
+  nil
+end
+
+def virtual_wire_return(method)
+  return { kind: :void } if method[:ffi_return] == :void
+  return { kind: :integer } if method[:ffi_return] == :int
+  return { kind: :boolean } if method[:ffi_return] == :bool
+  return { kind: :string } if method[:ffi_return] == :string && method[:return_cast] == :qstring_to_utf8
+  return { kind: :value, qt_class: method[:value_class] } if method[:return_cast] == :qt_value_copy
+  return { kind: :pointer, qt_class: method[:pointer_class] } if method[:ffi_return] == :pointer && method[:pointer_class]
+
+  nil
+end
+
+def virtual_method_wire_spec(method)
+  return nil unless method[:virtual] && !method[:static] && !method[:final]
+  return nil if method[:qt_name].start_with?('qt_') || forbidden_auto_exportable_method_name?(method[:qt_name])
+  return nil unless method[:args].length == method[:cpp_params].length
+
+  args = method[:args].map { |arg| virtual_wire_argument(arg) }
+  result = virtual_wire_return(method)
+  return nil if args.any?(&:nil?) || result.nil?
+
+  { args: args, return: result }
+end
+
+def assign_virtual_method_ids(specs, ast:)
+  next_id = 1
+  class_index = ast_class_index(ast)
+  specs.map do |spec|
+    constructor_mode = spec.dig(:constructor, :mode)
+    adapter_available = constructor_mode != :wrap_only && constructor_mode != :qapplication &&
+                        !class_index[:abstract_by_class][spec[:qt_class]] &&
+                        !class_index[:final_by_class][spec[:qt_class]]
+    methods = spec[:methods].map do |method|
+      wire_spec = virtual_method_wire_spec(method)
+      next method unless adapter_available && wire_spec
+
+      result = method.merge(virtual_method_id: next_id, virtual_wire: wire_spec)
+      next_id += 1
+      result
+    end
+    spec.merge(
+      methods: methods,
+      virtual_adapter: adapter_available && methods.any? { |method| method[:virtual_method_id] }
+    )
+  end
+end
+
+def generated_virtual_subclass_name(spec)
+  "QtRubyGenerated#{spec[:qt_class].gsub(/[^A-Za-z0-9_]/, '_')}Override"
+end
+
+def cpp_virtual_argument_wire_lines(arg, index)
+  expression = "arg#{index + 1}"
+  wire = virtual_wire_argument(arg)
+  case wire&.dig(:kind)
+  when :integer then ["arguments.append(static_cast<int>(#{expression}));"]
+  when :boolean then ["arguments.append(#{expression});"]
+  when :string then ["arguments.append(#{expression});"]
+  when :pointer, :value
+    pointer_expr = wire[:kind] == :pointer ? expression : "&#{expression}"
+    [
+      "if (#{pointer_expr}) {",
+      "  arguments.append(QString::number(static_cast<qulonglong>(reinterpret_cast<quintptr>(#{pointer_expr}))));",
+      '} else {',
+      '  arguments.append(QJsonValue(QJsonValue::Null));',
+      '}'
+    ]
+  else
+    []
+  end
+end
+
+def cpp_virtual_fallback_lines(method, spec, arg_names, indent: '      ')
+  invocation = "#{spec[:qt_class]}::#{method[:qt_name]}(#{arg_names.join(', ')})"
+  if method[:ffi_return] == :void
+    ["#{indent}#{invocation};", "#{indent}return;"]
+  else
+    ["#{indent}return #{invocation};"]
+  end
+end
+
+def cpp_virtual_response_lines(method, indent: '      ')
+  wire_return = method.dig(:virtual_wire, :return)
+  value = 'response_object.value(QStringLiteral("value"))'
+  case wire_return[:kind]
+  when :void
+    ["#{indent}return;"]
+  when :integer
+    ["#{indent}return static_cast<#{method[:cpp_return_type]}>(#{value}.toInt());"]
+  when :boolean
+    ["#{indent}return #{value}.toBool();"]
+  when :string
+    ["#{indent}return #{value}.toString();"]
+  when :pointer
+    [
+      "#{indent}const quintptr address = static_cast<quintptr>(#{value}.toString().toULongLong());",
+      "#{indent}return reinterpret_cast<#{method[:cpp_return_type]}>(address);"
+    ]
+  when :value
+    [
+      "#{indent}const quintptr address = static_cast<quintptr>(#{value}.toString().toULongLong());",
+      "#{indent}if (address == 0) return #{method[:cpp_return_type]}();",
+      "#{indent}return *reinterpret_cast<#{method[:cpp_return_type]}*>(address);"
+    ]
+  else
+    []
+  end
+end
+
+def generate_cpp_virtual_adapter(lines, spec)
+  methods = spec[:methods].select { |method| method[:virtual_method_id] }
+  return if methods.empty?
+
+  adapter_name = generated_virtual_subclass_name(spec)
+  lines << "class #{adapter_name} final : public #{spec[:qt_class]} {"
+  lines << 'public:'
+  lines << "  using #{spec[:qt_class]}::#{spec[:qt_class]};"
+  lines << "  ~#{adapter_name}() { QtRubyRuntime::set_virtual_dispatch_enabled(this, 0); }"
+  lines << ''
+  methods.each do |method|
+    arg_names = method[:args].each_index.map { |index| "arg#{index + 1}" }
+    cpp_params = method[:cpp_params].each_with_index.map { |type, index| "#{type} #{arg_names[index]}" }
+    const_qualifier = method[:cpp_const] ? ' const' : ''
+    lines << "  #{method[:cpp_return_type]} #{method[:qt_name]}(#{cpp_params.join(', ')})#{const_qualifier} override {"
+    lines << "    if (!QtRubyRuntime::virtual_dispatch_enabled(const_cast<#{adapter_name}*>(this))) {"
+    lines.concat(cpp_virtual_fallback_lines(method, spec, arg_names, indent: '      '))
+    lines << '    }'
+    lines << "    if (QtRubyRuntime::ruby_virtual_method_active(this, #{method[:virtual_method_id]})) {"
+    lines.concat(cpp_virtual_fallback_lines(method, spec, arg_names))
+    lines << '    }'
+    lines << '    QJsonArray arguments;'
+    method[:args].each_with_index do |arg, index|
+      cpp_virtual_argument_wire_lines(arg, index).each { |line| lines << "    #{line}" }
+    end
+    lines << '    const QByteArray payload = QJsonDocument(arguments).toJson(QJsonDocument::Compact);'
+    lines << "    const QByteArray response = QtRubyRuntime::dispatch_virtual_method(this, #{method[:virtual_method_id]}, payload);"
+    lines << '    QJsonParseError response_error;'
+    lines << '    const QJsonDocument response_document = QJsonDocument::fromJson(response, &response_error);'
+    lines << '    const QJsonObject response_object = response_document.object();'
+    lines << '    if (response_error.error == QJsonParseError::NoError && response_object.value(QStringLiteral("handled")).toBool()) {'
+    lines.concat(cpp_virtual_response_lines(method))
+    lines << '    }'
+    lines.concat(cpp_virtual_fallback_lines(method, spec, arg_names, indent: '    '))
+    lines << '  }'
+    lines << ''
+  end
+  lines << '};'
+  lines << ''
+end
+
 def assign_unique_native_method_name(spec, method, used)
   native_name = default_method_function_name(spec, method)
   return used_add_and_return(used, native_name, method) unless used.include?(native_name)
@@ -1039,16 +1390,35 @@ end
 
 def append_ruby_widgets_classes(lines, specs, super_qt_by_qt, wrapper_qt_classes)
   qapplication_spec = specs.find { |spec| spec[:ruby_class] == 'QApplication' }
-  generate_ruby_qapplication(lines, qapplication_spec)
-
   specs_by_qt = specs.each_with_object({}) { |spec, map| map[spec[:qt_class]] = spec }
   qt_to_ruby = build_qt_to_ruby_map(specs, wrapper_qt_classes)
   emitted_qts = qts_to_emit(specs, wrapper_qt_classes)
   emit_qt_classes(lines, emitted_qts, specs_by_qt, super_qt_by_qt, qt_to_ruby)
+  generate_ruby_qapplication(
+    lines,
+    qapplication_spec,
+    super_ruby: qt_to_ruby[super_qt_by_qt['QApplication']]
+  )
 end
 
 def generate_ruby_widgets(specs, super_qt_by_qt, wrapper_qt_classes)
   lines = ruby_widgets_prelude_lines
+  descriptors = specs.flat_map do |spec|
+    spec[:methods].filter_map do |method|
+      next unless method[:virtual_method_id]
+
+      {
+        id: method[:virtual_method_id],
+        wrapper_class: spec[:ruby_class],
+        ruby_name: ruby_safe_method_name(method[:ruby_name]),
+        snake_name: to_snake(ruby_safe_method_name(method[:ruby_name])),
+        args: method[:virtual_wire][:args],
+        return: method[:virtual_wire][:return]
+      }
+    end
+  end
+  lines << "  GENERATED_VIRTUAL_METHODS = #{descriptors.inspect}.freeze"
+  lines << '' unless descriptors.empty?
   append_ruby_widgets_classes(lines, specs, super_qt_by_qt, wrapper_qt_classes)
 
   lines << 'end'
@@ -1173,6 +1543,7 @@ def collect_qt_scoped_enum_constants(ast, warnings = [])
     next unless owner.match?(/\AQ[A-Z]\w*\z/)
     next if owner == 'Qt' || owner == 'QEvent'
 
+    next_value = 0
     Array(node['inner']).each do |entry|
       next unless entry['kind'] == 'EnumConstantDecl'
 
@@ -1181,7 +1552,13 @@ def collect_qt_scoped_enum_constants(ast, warnings = [])
 
       raw_value = ast_extract_first_value(entry)
       value = parse_ast_integer_value(raw_value)
-      next if value.nil?
+      value = next_value if value.nil? && !next_value.nil?
+      if value.nil?
+        next_value = nil
+        next
+      end
+
+      next_value = value + 1
 
       append_constant_with_conflict_warning(
         constants_by_owner[owner],
@@ -1240,7 +1617,9 @@ base_specs = timed('build_base_specs') { build_base_specs(ast) }
 timed('validate_qt_api') { validate_qt_api!(ast, base_specs) }
 expanded_specs = timed('expand_auto_methods') { expand_auto_methods(base_specs, ast) }
 property_specs = timed('enrich_specs_with_properties') { enrich_specs_with_properties(expanded_specs, ast) }
-effective_specs = timed('assign_unique_native_method_names') { assign_unique_native_method_names(property_specs) }
+effective_specs = timed('assign_unique_native_method_names') do
+  assign_virtual_method_ids(assign_unique_native_method_names(property_specs), ast: ast)
+end
 super_qt_by_qt, wrapper_qt_classes = timed('build_generated_inheritance') do
   build_generated_inheritance(ast, effective_specs)
 end