qt 0.1.9 → 0.2.1

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,147 +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[: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],
-    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]
-    }
-  }
-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],
-      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,8 +333,18 @@ 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
-    discover_related_qobject_wrapper_classes(ast, targets, all_classes, template_classes, scope).sort
+    seed_classes = (targets + ['QApplication']).uniq
+    discover_related_qobject_wrapper_classes(ast, seed_classes, all_classes, template_classes, scope).sort
   end
   targets = (targets + wrapper_targets).uniq.sort
   debug_log(
@@ -391,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,
@@ -410,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.