qt 0.1.9 → 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,32 +61,52 @@ 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)
+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+/, ' ')
 
   type = raw
   type = type.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
-  return nil if unsupported_cpp_type?(type)
+  return { ffi: :string, cast: :qint_list_from_variant } if type == 'QList<int>'
   return { ffi: :string, cast: :qstring } if type == 'QString'
   return { ffi: :string, cast: :qdatetime_from_utf8 } if type == 'QDateTime'
   return { ffi: :string, cast: :qdate_from_utf8 } if type == 'QDate'
@@ -58,7 +118,13 @@ def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil)
   return { ffi: :string, cast: :qvariant_from_utf8 } if type == 'QVariant'
   return { ffi: :string } if compact_raw.match?(/\Aconst\s+char\s*\*\z/)
 
-  map_cpp_pointer_arg_type(type, qt_class) || map_cpp_intlike_arg_type(type, qt_class, int_cast_types)
+  if ast_qt_value_class?(ast, type)
+    return { ffi: :pointer, cast: :qt_value_ref, value_class: type }
+  end
+
+  return nil if unsupported_cpp_type?(type)
+
+  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)
@@ -68,13 +134,34 @@ 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?('*')
 
-  type = raw.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
-  map_scalar_cpp_return_type(type) || map_pointer_cpp_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)
+  return false unless ast && type.match?(/\AQ[A-Z]\w*\z/)
+  return false unless ast_class_index(ast)[:methods_by_class].key?(type)
+
+  !class_inherits?(ast, type, 'QObject')
+end
+
+def map_qt_value_return_type(type, ast:)
+  return nil unless ast_qt_value_class?(ast, type)
+
+  { ffi_return: :pointer, return_cast: :qt_value_copy, value_class: type }
 end
 
 def map_scalar_cpp_return_type(type)
@@ -82,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'
@@ -135,7 +223,7 @@ def parse_method_signature(method_decl)
   }
 end
 
-def build_auto_method_args(parsed, entry, qt_class, int_cast_types)
+def build_auto_method_args(parsed, entry, qt_class, int_cast_types, ast)
   arg_cast_overrides = Array(entry[:arg_casts])
   params = parsed[:params]
   required_arg_count = 0
@@ -143,7 +231,7 @@ def build_auto_method_args(parsed, entry, qt_class, int_cast_types)
 
   params.each_with_index do |param, idx|
     cast_override = arg_cast_overrides[idx]
-    arg_info = map_cpp_arg_type(param[:type], qt_class: qt_class, int_cast_types: int_cast_types)
+    arg_info = map_cpp_arg_type(param[:type], qt_class: qt_class, int_cast_types: int_cast_types, ast: ast)
     arg_info ||= { ffi: :int } if cast_override
     unless arg_info
       return nil unless skip_unsupported_optional_tail?(params, idx, param)
@@ -151,7 +239,13 @@ def build_auto_method_args(parsed, entry, qt_class, int_cast_types)
       break
     end
 
-    args << { name: param[:name], ffi: arg_info[:ffi], cast: cast_override || arg_info[:cast] }.compact
+    args << {
+      name: param[:name],
+      ffi: arg_info[:ffi],
+      cast: cast_override || arg_info[:cast],
+      value_class: arg_info[:value_class],
+      cpp_type: param[:type]
+    }.compact
     required_arg_count += 1 unless param[:has_default]
   end
 
@@ -172,8 +266,10 @@ 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]
   method
 end
 
@@ -181,10 +277,10 @@ 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)
+  args, required_arg_count = build_auto_method_args(parsed, entry, qt_class, int_cast_types, ast)
   return nil unless args
 
   build_auto_method_hash(entry, ret_info, args, required_arg_count)
@@ -237,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,
@@ -246,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)
@@ -352,7 +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 { |candidate| candidate[:method][:args].length }[:method]
+  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 }
+    [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)
@@ -371,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

@@ -10,6 +10,9 @@ class CppMethodReturnEmitter
 
   def emit
     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?
@@ -17,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
@@ -54,52 +58,99 @@ class CppMethodReturnEmitter
   end
 
   def emit_qstring
-    lines << "  const QString value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = value.toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QString #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = #{result}.toUtf8();"
+    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
-    lines << "  const QVariant value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qvariant_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QVariant #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qvariant_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qobject_list
-    lines << "  const QObjectList value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qobject_list_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QObjectList #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qobject_list_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qdatetime
-    lines << "  const QDateTime value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qdatetime_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QDateTime #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qdatetime_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qdate
-    lines << "  const QDate value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qdate_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QDate #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qdate_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qtime
-    lines << "  const QTime value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qtime_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QTime #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qtime_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_pointer
     lines << "  return const_cast<void*>(static_cast<const void*>(#{invocation}));"
   end
 
+  def emit_qt_value_copy
+    lines << "  return new #{method[:value_class]}(#{invocation});"
+  end
+
+  def emit_qint_list
+    result = unique_local_name('result')
+    variant = unique_local_name('variant')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QList<int> #{result} = #{invocation};"
+    lines << "  const QVariant #{variant} = QtRubyRuntime::qvariant_from_qint_list(#{result});"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qvariant_to_bridge_string(#{variant}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
+  end
+
   def emit_value
     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}"
+    candidate += '_' while used.include?(candidate)
+    candidate
+  end
 end

data/scripts/generate_bridge/ffi_api.rb

@@ -15,9 +15,25 @@ def all_ffi_functions(specs, free_function_specs:)
     append_method_ffi_functions(fns, spec)
   end
 
+  value_wrapper_classes(specs, free_function_specs: free_function_specs).each do |qt_class|
+    fns << { name: qt_value_delete_function_name(qt_class), ffi_return: :void, args: [:pointer] }
+  end
+
   fns
 end
 
+def value_wrapper_classes(specs, free_function_specs: [])
+  spec_classes = specs.flat_map do |spec|
+    spec[:methods].filter_map { |method| method[:value_class] if method[:return_cast] == :qt_value_copy }
+  end
+  free_classes = free_function_specs.filter_map { |spec| spec[:value_class] }
+  (spec_classes + free_classes).uniq.sort
+end
+
+def qt_value_delete_function_name(qt_class)
+  "qt_ruby_#{to_snake(qt_class)}_value_delete"
+end
+
 def append_constructor_ffi_function(fns, spec)
   return if spec[:constructor][:mode] == :wrap_only
 
@@ -42,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