qt 0.2.0 → 0.2.1

data/scripts/generate_bridge/auto_methods.rb

@@ -4,12 +4,52 @@ def unsupported_cpp_type?(type_name)
   type_name.include?('<') || type_name.include?('>') || type_name.include?('[') || type_name.include?('(')
 end
 
-def map_cpp_pointer_arg_type(type_name, qt_class)
+def ast_nested_types_by_class(ast)
+  @ast_nested_types_cache ||= {}.compare_by_identity
+  @ast_nested_types_cache[ast] ||= begin
+    nested = Hash.new { |hash, key| hash[key] = Set.new }
+    walk = lambda do |node, record_stack|
+      next unless node.is_a?(Hash)
+
+      parent_record = record_stack.last
+      nested_type_kind = %w[CXXRecordDecl EnumDecl TypedefDecl TypeAliasDecl].include?(node['kind'])
+      if nested_type_kind && parent_record && node['name'] && node['name'] != parent_record['name'] &&
+         (node['parentDeclContextId'].nil? || node['parentDeclContextId'] == parent_record['id'])
+        nested[parent_record['name']] << node['name']
+      end
+
+      child_stack = if node['kind'] == 'CXXRecordDecl' && node['name']
+                      record_stack + [node]
+                    else
+                      record_stack
+                    end
+      Array(node['inner']).each { |child| walk.call(child, child_stack) }
+    end
+    walk.call(ast, [])
+    nested
+  end
+end
+
+def ast_nested_type_owner(ast, qt_class, nested_name, visited = {})
+  return nil if qt_class.nil? || visited[qt_class]
+
+  visited[qt_class] = true
+  return qt_class if ast_nested_types_by_class(ast)[qt_class].include?(nested_name)
+
+  collect_class_bases(ast, qt_class).each do |base_class|
+    owner = ast_nested_type_owner(ast, base_class, nested_name, visited)
+    return owner if owner
+  end
+  nil
+end
+
+def map_cpp_pointer_arg_type(type_name, qt_class, ast:)
   return nil unless type_name.end_with?('*')
 
   base = type_name.sub(/\s*\*\z/, '').strip
-  if qt_class && !base.include?('::') && base.match?(/\A[A-Z]\w*\z/) && !base.start_with?('Q')
-    base = "#{qt_class}::#{base}"
+  if qt_class && !base.include?('::') && base.match?(/\A[A-Z]\w*\z/)
+    owner = ast_nested_type_owner(ast, qt_class, base)
+    base = "#{owner}::#{base}" if owner
   end
   { ffi: :pointer, cast: "#{base}*" }
 end
@@ -21,26 +61,46 @@ def map_builtin_intlike_arg_type(type_name)
   nil
 end
 
-def map_qualified_intlike_arg_type(type_name, qt_class, int_cast_types)
-  return nil unless qt_class && type_name.match?(/\A[A-Z]\w*\z/)
+def inherited_intlike_type_name(type_name, qt_class, ast, int_cast_types, visited = {})
+  return nil if qt_class.nil? || visited[qt_class]
 
+  visited[qt_class] = true
   qualified = "#{qt_class}::#{type_name}"
-  return { ffi: :int, cast: qualified } if int_cast_types&.include?(qualified)
+  return qualified if int_cast_types&.include?(qualified)
+
+  collect_class_bases(ast, qt_class).each do |base_class|
+    inherited = inherited_intlike_type_name(type_name, base_class, ast, int_cast_types, visited)
+    return inherited if inherited
+  end
+  nil
+end
+
+def map_qualified_intlike_arg_type(type_name, qt_class, int_cast_types, ast:)
+  return nil unless qt_class && type_name.match?(/\A[A-Z]\w*\z/)
+
+  qualified = inherited_intlike_type_name(type_name, qt_class, ast, int_cast_types)
+  return { ffi: :int, cast: qualified } if qualified
 
   nil
 end
 
-def map_cpp_intlike_arg_type(type_name, qt_class, int_cast_types)
+def map_cpp_intlike_arg_type(type_name, qt_class, int_cast_types, ast:)
   builtin = map_builtin_intlike_arg_type(type_name)
   return builtin if builtin
   return { ffi: :int, cast: type_name } if type_name.include?('::') && int_cast_types&.include?(type_name)
 
-  map_qualified_intlike_arg_type(type_name, qt_class, int_cast_types)
+  map_qualified_intlike_arg_type(type_name, qt_class, int_cast_types, ast: ast)
 end
 
 def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil, ast: nil)
   raw = type_name.to_s.strip
-  return nil if raw.end_with?('&') && !raw.start_with?('const ')
+  if raw.end_with?('&') && !raw.start_with?('const ')
+    mutable_reference_type = normalized_cpp_type_name(raw)
+    return nil if SCALAR_BRIDGED_QT_TYPES.include?(mutable_reference_type) || %w[QCursor QIcon].include?(mutable_reference_type)
+    return nil unless ast_qt_value_class?(ast, mutable_reference_type)
+
+    return { ffi: :pointer, cast: :qt_value_ref, value_class: mutable_reference_type }
+  end
 
   compact_raw = raw.gsub(/\s+/, ' ')
 
@@ -64,7 +124,7 @@ def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil, ast: nil)
 
   return nil if unsupported_cpp_type?(type)
 
-  map_cpp_pointer_arg_type(type, qt_class) || map_cpp_intlike_arg_type(type, qt_class, int_cast_types)
+  map_cpp_pointer_arg_type(type, qt_class, ast: ast) || map_cpp_intlike_arg_type(type, qt_class, int_cast_types, ast: ast)
 end
 
 def normalized_cpp_type_name(type_name)
@@ -74,14 +134,21 @@ def normalized_cpp_type_name(type_name)
   type
 end
 
-def map_cpp_return_type(type_name, ast: nil)
+def map_cpp_return_type(type_name, ast: nil, qt_class: nil)
   raw = type_name.to_s.strip
   type = raw.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
   return { ffi_return: :string, return_cast: :qint_list_to_variant } if type == 'QList<int>'
   return nil if unsupported_cpp_type?(raw)
   return nil if raw.start_with?('const ') && raw.end_with?('*')
 
-  map_scalar_cpp_return_type(type) || map_pointer_cpp_return_type(type, ast: ast) || map_qt_value_return_type(type, ast: ast)
+  scalar = map_scalar_cpp_return_type(type)
+  return scalar if scalar
+
+  int_cast_types = ast ? ast_int_cast_type_set(ast) : nil
+  intlike = map_cpp_intlike_arg_type(type, qt_class, int_cast_types, ast: ast)
+  return { ffi_return: :int, return_cast: :int_cast } if intlike
+
+  map_pointer_cpp_return_type(type, ast: ast) || map_qt_value_return_type(type, ast: ast)
 end
 
 def ast_qt_value_class?(ast, type)
@@ -102,6 +169,7 @@ def map_scalar_cpp_return_type(type)
   return { ffi_return: :int } if type == 'int'
   return { ffi_return: :bool } if type == 'bool'
   return { ffi_return: :string, return_cast: :qstring_to_utf8 } if type == 'QString'
+  return { ffi_return: :string, return_cast: :qstring_list_to_json } if type == 'QStringList'
   return { ffi_return: :string, return_cast: :qobject_list_to_wrapped_array, object_list_class: 'QObject' } if type == 'QObjectList'
   return { ffi_return: :string, return_cast: :qdatetime_to_utf8 } if type == 'QDateTime'
   return { ffi_return: :string, return_cast: :qdate_to_utf8 } if type == 'QDate'
@@ -175,7 +243,8 @@ def build_auto_method_args(parsed, entry, qt_class, int_cast_types, ast)
       name: param[:name],
       ffi: arg_info[:ffi],
       cast: cast_override || arg_info[:cast],
-      value_class: arg_info[:value_class]
+      value_class: arg_info[:value_class],
+      cpp_type: param[:type]
     }.compact
     required_arg_count += 1 unless param[:has_default]
   end
@@ -197,6 +266,7 @@ def build_auto_method_hash(entry, ret_info, args, required_arg_count)
     args: args,
     required_arg_count: required_arg_count
   }
+  method[:static] = entry[:static] if entry.key?(:static)
   method[:return_cast] = ret_info[:return_cast] if ret_info[:return_cast]
   method[:pointer_class] = ret_info[:pointer_class] if ret_info[:pointer_class]
   method[:value_class] = ret_info[:value_class] if ret_info[:value_class]
@@ -207,7 +277,7 @@ def build_auto_method_from_decl(method_decl, entry, qt_class:, int_cast_types:,
   parsed = parse_method_signature(method_decl)
   return nil unless parsed
 
-  ret_info = map_cpp_return_type(parsed[:return_type], ast: ast)
+  ret_info = map_cpp_return_type(parsed[:return_type], ast: ast, qt_class: qt_class)
   return nil unless ret_info
 
   args, required_arg_count = build_auto_method_args(parsed, entry, qt_class, int_cast_types, ast)
@@ -263,8 +333,15 @@ def build_auto_method_candidate(ast, decl, entry, qt_class, int_cast_types)
   parsed = parse_method_signature(decl)
   return nil unless parsed
 
-  method = build_auto_method_from_decl(decl, entry, qt_class: qt_class, int_cast_types: int_cast_types, ast: ast)
+  method_entry = entry.merge(static: decl['storageClass'] == 'static')
+  method = build_auto_method_from_decl(decl, method_entry, qt_class: qt_class, int_cast_types: int_cast_types, ast: ast)
   return nil unless method
+  method[:owner_class] = qt_class if method[:static]
+  method[:cpp_return_type] = parsed[:return_type]
+  method[:virtual] = virtual_method_declaration?(ast, decl)
+  method[:cpp_const] = decl.dig('type', 'qualType').to_s.match?(/\)\s*const\b/)
+  method[:cpp_params] = parsed[:params].map { |param| param[:type] }
+  method[:final] = final_method_declaration?(ast, decl)
 
   {
     method: method,
@@ -272,6 +349,77 @@ def build_auto_method_candidate(ast, decl, entry, qt_class, int_cast_types)
   }
 end
 
+def method_declaration_signature_key(decl)
+  parsed = parse_method_signature(decl)
+  return nil unless parsed
+
+  params = parsed[:params].map do |param|
+    param[:type].to_s.gsub(/\s+/, ' ').gsub(/\s*([*&])\s*/, '\\1').strip
+  end
+  const_method = decl.dig('type', 'qualType').to_s.match?(/\)\s*const\b/)
+  [params, const_method]
+end
+
+def method_declaration_has_attribute?(decl, attribute)
+  if attribute == 'OverrideAttr'
+    return decl['virtual'] == true || Array(decl['inner']).any? { |node| node['kind'] == attribute }
+  end
+
+  Array(decl['inner']).any? { |node| node['kind'] == attribute }
+end
+
+def inherited_method_attribute?(ast, owner_class, method_name, signature_key, attribute, visited = {})
+  return false if owner_class.nil? || visited[owner_class]
+
+  visited[owner_class] = true
+  collect_class_bases(ast, owner_class).any? do |base_class|
+    matching_declaration = collect_method_decls(ast, base_class, method_name).find do |candidate|
+      method_declaration_signature_key(candidate) == signature_key
+    end
+    next true if matching_declaration && method_declaration_has_attribute?(matching_declaration, attribute)
+    next false unless matching_declaration
+
+    inherited_method_attribute?(
+      ast,
+      base_class,
+      method_name,
+      signature_key,
+      attribute,
+      visited
+    )
+  end
+end
+
+def method_inherits_attribute?(ast, decl, attribute)
+  return true if method_declaration_has_attribute?(decl, attribute)
+
+  owner_class = decl['__owner_class']
+  signature_key = method_declaration_signature_key(decl)
+  return false unless owner_class && signature_key
+
+  cache = (@inherited_method_attribute_cache ||= {}.compare_by_identity)
+  per_ast = (cache[ast] ||= {})
+  cache_key = [owner_class, decl['name'], signature_key, attribute]
+  return per_ast[cache_key] if per_ast.key?(cache_key)
+
+  per_ast[cache_key] = inherited_method_attribute?(
+    ast,
+    owner_class,
+    decl['name'],
+    signature_key,
+    attribute
+  )
+end
+
+def virtual_method_declaration?(ast, decl)
+  method_inherits_attribute?(ast, decl, 'OverrideAttr') ||
+    decl['virtual'] == true
+end
+
+def final_method_declaration?(ast, decl)
+  method_inherits_attribute?(ast, decl, 'FinalAttr')
+end
+
 def auto_method_decl_candidate?(decl)
   return false unless decl['__effective_access'] == 'public'
   return false if deprecated_method_decl?(decl)
@@ -378,11 +526,13 @@ def resolve_auto_method(ast, qt_class, auto_entry)
   built = resolve_auto_method_built_candidates(ast, qt_class, entry)
   return per_ast_cache[cache_key] = nil unless built
 
-  per_ast_cache[cache_key] = built.min_by do |candidate|
+  methods = built.uniq { |candidate| candidate[:param_types] }
+                 .sort_by do |candidate|
     method = candidate[:method]
     value_arg_count = method[:args].count { |arg| arg[:cast] == :qt_value_ref }
-    [value_arg_count, method[:args].length]
-  end[:method]
+    [method[:required_arg_count], -value_arg_count, method[:args].length, candidate[:param_types]]
+  end.map { |candidate| candidate[:method] }
+  per_ast_cache[cache_key] = methods
 end
 
 def auto_entries_for_spec(spec, ast)
@@ -401,9 +551,10 @@ def resolve_auto_methods_for_spec(ast, spec, auto_entries, manual_methods, auto_
   resolver = build_auto_method_resolver(ast, spec, manual_methods, auto_mode)
   spec_resolved = 0
   spec_skipped = 0
-  auto_methods = auto_entries.filter_map do |entry|
+  auto_methods = []
+  auto_entries.each do |entry|
     method, spec_skipped, spec_resolved = resolve_with_resolver(resolver, entry, spec_skipped, spec_resolved)
-    method
+    auto_methods.concat(Array(method))
   end
 
   [auto_methods, spec_resolved, spec_skipped]

data/scripts/generate_bridge/cpp_method_return_emitter.rb

@@ -12,6 +12,7 @@ class CppMethodReturnEmitter
     return emit_void if method[:ffi_return] == :void
     return emit_qt_value_copy if method[:return_cast] == :qt_value_copy
     return emit_qint_list if method[:return_cast] == :qint_list_to_variant
+    return emit_qstring_list if method[:return_cast] == :qstring_list_to_json
     return emit_qstring if qstring_return?
     return emit_qobject_list if qobject_list_return?
     return emit_qdatetime if qdatetime_return?
@@ -19,6 +20,7 @@ class CppMethodReturnEmitter
     return emit_qtime if qtime_return?
     return emit_qvariant if qvariant_return?
     return emit_pointer if method[:ffi_return] == :pointer
+    return emit_int_cast if method[:return_cast] == :int_cast
 
     emit_value
   end
@@ -64,6 +66,15 @@ class CppMethodReturnEmitter
     lines << "  return #{utf8}.constData();"
   end
 
+  def emit_qstring_list
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QStringList #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qstring_list_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
+  end
+
   def emit_qvariant
     result = unique_local_name('result')
     utf8 = unique_local_name('utf8')
@@ -132,6 +143,10 @@ class CppMethodReturnEmitter
     lines << "  return #{invocation};"
   end
 
+  def emit_int_cast
+    lines << "  return static_cast<int>(#{invocation});"
+  end
+
   def unique_local_name(suffix)
     used = Array(method[:args]).map { |arg| arg[:name].to_s }.to_set
     candidate = "qt_ruby_#{suffix}"

data/scripts/generate_bridge/ffi_api.rb

@@ -58,7 +58,7 @@ end
 
 def append_method_ffi_functions(fns, spec)
   spec[:methods].each do |method|
-    args = [:pointer] + method[:args].map { |arg| arg[:ffi] }
+    args = [:pointer] + (method[:dispatch] ? [:int] : []) + method[:args].map { |arg| arg[:ffi] }
     fns << { name: method_function_name(spec, method), ffi_return: method[:ffi_return], args: args }
   end
 end

data/scripts/generate_bridge/free_function_specs.rb

@@ -2,24 +2,12 @@
 
 RUNTIME_HEADER_PATH = File.expand_path('../../ext/qt_ruby_bridge/qt_ruby_runtime.hpp', __dir__)
 
-SCALAR_CLASS_METHOD_FFI_RETURNS = %i[void int bool string pointer].freeze
-QAPPLICATION_STATIC_METHOD_EXCLUSIONS = %w[exec].freeze
-QAPPLICATION_STATIC_TEXT_SETTERS = %w[
-  setApplicationName
-  setDesktopFileName
-  setOrganizationName
-  setApplicationDisplayName
-].freeze
-
 def qt_free_function_specs(ast)
   @qt_free_function_specs_cache ||= {}.compare_by_identity
   return @qt_free_function_specs_cache[ast] if @qt_free_function_specs_cache.key?(ast)
 
   qt_specs = []
   qt_specs << qversion_free_function_spec(ast)
-  qt_specs.concat(qapplication_static_free_function_specs(ast))
-  qt_specs.concat(qapplication_static_text_setter_specs(ast))
-  qt_specs << qapplication_top_level_widgets_count_spec(ast)
   runtime_specs = runtime_free_function_specs_from_header
   @qt_free_function_specs_cache[ast] = merge_free_function_specs(qt_specs, runtime_specs).freeze
 end
@@ -140,152 +128,6 @@ def qversion_free_function_spec(ast)
   }
 end
 
-def qapplication_top_level_widgets_count_spec(ast)
-  has_top_level_widgets = collect_method_decls_with_bases(ast, 'QApplication', 'topLevelWidgets').any?
-  raise 'Unable to find QApplication::topLevelWidgets in AST' unless has_top_level_widgets
-
-  {
-    name: 'qt_ruby_qapplication_top_level_widgets_count',
-    ffi_return: :int,
-    args: [],
-    cpp_return: 'int',
-    cpp_args: '',
-    cpp_body: ['return QApplication::topLevelWidgets().size();'],
-    qapplication_method: { ruby_name: 'topLevelWidgetsCount', native: 'qapplication_top_level_widgets_count', args: [] }
-  }
-end
-
-def qapplication_static_free_function_specs(ast)
-  int_cast_types = ast_int_cast_type_set(ast)
-  method_names = collect_method_names_with_bases(ast, 'QApplication').uniq
-  method_names -= QAPPLICATION_STATIC_METHOD_EXCLUSIONS
-  method_names.filter_map do |qt_name|
-    build_qapplication_static_free_function_spec(ast, qt_name, int_cast_types)
-  end
-end
-
-def qapplication_static_text_setter_specs(ast)
-  QAPPLICATION_STATIC_TEXT_SETTERS.filter_map do |qt_name|
-    build_qapplication_static_text_setter_spec(ast, qt_name)
-  end
-end
-
-def build_qapplication_static_text_setter_spec(ast, qt_name)
-  return nil unless resolve_qapplication_static_text_setter_candidate(ast, qt_name)
-
-  native_name = "qapplication_#{to_snake(qt_name)}"
-  {
-    name: "qt_ruby_#{native_name}",
-    ffi_return: :void,
-    args: [:string],
-    cpp_return: 'void',
-    cpp_args: 'const char* value',
-    cpp_body: ["QApplication::#{qt_name}(as_qstring(value));"],
-    qapplication_method: {
-      ruby_name: qt_name,
-      native: native_name,
-      args: [{ name: :value, ffi: :string, cast: :qstring }],
-      required_arg_count: 1
-    }
-  }
-end
-
-def resolve_qapplication_static_text_setter_candidate(ast, qt_name)
-  decls = collect_method_decls_with_bases(ast, 'QApplication', qt_name)
-  decls.any? do |decl|
-    next false unless decl['storageClass'] == 'static'
-    next false unless decl['__effective_access'] == 'public'
-
-    parsed = parse_method_signature(decl)
-    next false unless parsed
-    next false unless parsed[:return_type].to_s.strip == 'void'
-    next false unless parsed[:required_arg_count] == 1
-    next false unless parsed[:params].length == 1
-
-    normalized = normalized_cpp_type_name(parsed[:params].first[:type])
-    normalized == 'QString'
-  end
-end
-
-def build_qapplication_static_free_function_spec(ast, qt_name, int_cast_types)
-  candidate = resolve_qapplication_static_noarg_candidate(ast, qt_name, int_cast_types)
-  return nil unless candidate
-
-  native_name = "qapplication_#{to_snake(qt_name)}"
-  cpp_body =
-    if candidate[:ffi_return] == :void
-      ["QApplication::#{qt_name}();"]
-    elsif candidate[:return_cast] == :qt_value_copy
-      ["return new #{candidate[:value_class]}(QApplication::#{qt_name}());"]
-    elsif candidate[:enum_cast]
-      ["return static_cast<int>(QApplication::#{qt_name}());"]
-    elsif candidate[:ffi_return] == :string
-      [
-        "const QString value = QApplication::#{qt_name}();",
-        'thread_local QByteArray utf8;',
-        'utf8 = value.toUtf8();',
-        'return utf8.constData();'
-      ]
-    else
-      ["return QApplication::#{qt_name}();"]
-    end
-
-  {
-    name: "qt_ruby_#{native_name}",
-    ffi_return: candidate[:ffi_return],
-    value_class: candidate[:value_class],
-    args: [],
-    cpp_return: ffi_return_to_cpp(candidate[:ffi_return]),
-    cpp_args: '',
-    cpp_body: cpp_body,
-    qapplication_method: {
-      ruby_name: qt_name,
-      native: native_name,
-      args: [],
-      return_cast: candidate[:return_cast],
-      pointer_class: candidate[:pointer_class],
-      value_class: candidate[:value_class]
-    }
-  }
-end
-
-def resolve_qapplication_static_noarg_candidate(ast, qt_name, int_cast_types)
-  decls = collect_method_decls_with_bases(ast, 'QApplication', qt_name)
-  candidates = decls.filter_map do |decl|
-    next unless decl['storageClass'] == 'static'
-    next unless decl['__effective_access'] == 'public'
-
-    parsed = parse_method_signature(decl)
-    next unless parsed && parsed[:required_arg_count].zero?
-
-    ret_info = qapplication_static_return_info(parsed[:return_type], int_cast_types, ast: ast)
-    next unless ret_info
-
-    { decl: decl, param_count: parsed[:params].length }.merge(ret_info)
-  end
-  return nil if candidates.empty?
-
-  candidates.min_by { |item| item[:param_count] }
-end
-
-def qapplication_static_return_info(return_type, int_cast_types, ast:)
-  mapped = map_cpp_return_type(return_type, ast: ast)
-  if mapped && SCALAR_CLASS_METHOD_FFI_RETURNS.include?(mapped[:ffi_return])
-    return {
-      ffi_return: mapped[:ffi_return],
-      return_cast: mapped[:return_cast],
-      pointer_class: mapped[:pointer_class],
-      value_class: mapped[:value_class],
-      enum_cast: false
-    }
-  end
-
-  normalized = normalized_cpp_type_name(return_type)
-  return nil unless normalized.include?('::') && int_cast_types.include?(normalized)
-
-  { ffi_return: :int, return_cast: nil, enum_cast: true }
-end
-
 def qapplication_class_method_specs(ast)
   qt_free_function_specs(ast).filter_map { |spec| spec[:qapplication_method] }
 end

data/scripts/generate_bridge/spec_discovery.rb

@@ -12,7 +12,7 @@ def constructor_supports_parent_only?(decl)
   return false if params.empty?
 
   first_type = normalized_cpp_type_name(params.first[:type])
-  return false unless %w[QWidget* QObject*].include?(first_type)
+  return false unless first_type.match?(/\AQ[A-Z]\w*\*\z/)
 
   params.drop(1).all? { |param| param[:has_default] }
 end
@@ -44,7 +44,7 @@ def parent_constructor_first_type(decl)
   return nil if params.empty?
 
   first_type = normalized_cpp_type_name(params.first[:type])
-  return nil unless %w[QWidget* QObject*].include?(first_type)
+  return nil unless first_type.match?(/\AQ[A-Z]\w*\*\z/)
   return nil unless params.drop(1).all? { |param| param[:has_default] }
 
   first_type
@@ -139,7 +139,7 @@ def discover_related_value_classes(ast, seed_classes, all_classes, template_clas
 
   until queue.empty?
     klass = queue.shift
-    related_qt_type_names(ast, klass).each do |candidate|
+    (related_qt_type_names(ast, klass).to_a + derived_qt_classes(ast, klass, all_classes)).uniq.each do |candidate|
       next if discovered.include?(candidate)
       next unless related_value_class_candidate?(ast, candidate, all_classes, template_classes)
 
@@ -151,6 +151,42 @@ def discover_related_value_classes(ast, seed_classes, all_classes, template_clas
   discovered.to_a
 end
 
+def derived_qt_classes(ast, qt_class, all_classes)
+  all_classes.select { |candidate| candidate != qt_class && class_inherits?(ast, candidate, qt_class) }
+end
+
+def discover_related_static_api_classes(ast, seed_classes, all_classes, template_classes)
+  discovered = seed_classes.to_set
+  loop do
+    added = all_classes.select do |owner|
+      next false if discovered.include?(owner) || template_classes.include?(owner)
+
+      method_decls_for_related_wrapper_scan(ast, owner).any? do |decl|
+        next false unless decl['storageClass'] == 'static'
+        next false unless decl['__effective_access'] == 'public'
+
+        parsed = parse_method_signature(decl)
+        next false unless parsed
+
+        return_type = related_qt_type_name(parsed[:return_type])
+        next false unless discovered.include?(return_type)
+
+        !build_auto_method_from_decl(
+          decl,
+          { qt_name: decl['name'] },
+          qt_class: owner,
+          int_cast_types: ast_int_cast_type_set(ast),
+          ast: ast
+        ).nil?
+      end
+    end
+    break if added.empty?
+
+    discovered.merge(added)
+  end
+  discovered.to_a - seed_classes
+end
+
 def discover_related_qobject_wrapper_classes(ast, seed_classes, all_classes, template_classes, scope)
   discovered = seed_classes.to_set
   queue = seed_classes.dup
@@ -265,9 +301,7 @@ def append_related_qt_types_from_decl(out, parsed, method_name)
   candidates << [related_qt_type_name(parsed[:return_type]), parsed[:return_type].to_s] if parsed[:return_type]
   parsed[:params].each { |param| candidates << [related_qt_type_name(param[:type]), param[:type].to_s] }
   candidates.each do |candidate, raw_type|
-    next if candidate.empty? || !candidate.start_with?('Q')
-    next unless related_type_name_matches_method?(candidate, method_name) ||
-                (qt_pointer_type?(raw_type) && candidate.end_with?('Item'))
+    next unless candidate.match?(/\AQ[A-Z]\w*\z/)
 
     out << candidate
   end
@@ -299,6 +333,15 @@ def discover_target_qt_classes(ast, scope)
   targets = timed("discover_target_qt_classes/#{scope}/related") do
     discover_related_value_classes(ast, base_targets, all_classes, template_classes).sort
   end
+  targets = timed("discover_target_qt_classes/#{scope}/static_api_owners") do
+    related_static_owners = discover_related_static_api_classes(
+      ast,
+      (targets + ['QApplication']).uniq,
+      all_classes,
+      template_classes
+    )
+    (targets + related_static_owners).sort
+  end
   wrapper_targets = timed("discover_target_qt_classes/#{scope}/related_qobject_wrappers") do
     seed_classes = (targets + ['QApplication']).uniq
     discover_related_qobject_wrapper_classes(ast, seed_classes, all_classes, template_classes, scope).sort
@@ -392,17 +435,14 @@ def constructor_string_path_cast(ctor_decls)
   ctor_decls.filter_map do |decl|
     parsed = parse_method_signature(decl)
     next nil unless parsed && parsed[:params].first
+    next nil unless parsed[:required_arg_count] <= 1
+    next nil unless parsed[:params].drop(1).all? { |param| param[:has_default] }
 
     constructor_string_like_arg_cast(parsed[:params].first[:type])
   end.first
 end
 
 def base_spec_hash(qt_class, parent_ctor)
-  auto_method_rules = {}
-  # Prefer QShortcut#setKeys(StandardKey) in generated API and provide
-  # QKeySequence path via setKey(QKeySequence) + Ruby-level compatibility shim.
-  auto_method_rules[:setKeys] = { param_types: ['QKeySequence::StandardKey'] } if qt_class == 'QShortcut'
-
   {
     qt_class: qt_class,
     ruby_class: qt_class,
@@ -411,7 +451,6 @@ def base_spec_hash(qt_class, parent_ctor)
     constructor: parent_ctor,
     methods: [],
     auto_methods: :all,
-    auto_method_rules: auto_method_rules,
     # Constructor availability is already filtered during discovery.
     # Keep validation lightweight for auto-discovered classes to avoid false negatives
     # on template/specialized constructor names in Clang AST.