From 298e5a4b432bab97ba0dc0c24174428fb6550e03 Mon Sep 17 00:00:00 2001 From: Brendan Szymanski Date: Tue, 11 Aug 2026 23:47:16 -0400 Subject: [PATCH] Bind the GIO async pattern as Swift async methods --- .../GObjectGeneratorCore/BindingPlan.swift | 56 ++- .../GObjectGeneratorCore/PlanRenderer.swift | 140 +++++- Sources/GObjectGeneratorCore/Planner.swift | 248 ++++++++++- Sources/GObjectGeneratorCore/TypeMapper.swift | 34 +- .../AsyncCallableTests.swift | 146 ++++++ .../CallbackGenerationTests.swift | 37 ++ .../TypeMapperTests.swift | 31 ++ regression/tier6/Adw.json | 20 +- regression/tier6/GLib.json | 320 +------------ regression/tier6/GObject.json | 12 - regression/tier6/Gdk.json | 100 +---- regression/tier6/GdkPixbuf.json | 16 +- regression/tier6/Gio.json | 420 +----------------- regression/tier6/Graphene.json | 150 ------- regression/tier6/Gsk.json | 18 - regression/tier6/Gst.json | 196 +------- regression/tier6/Gtk.json | 100 +---- regression/tier6/Pango.json | 30 -- regression/tier6/Soup.json | 46 +- 19 files changed, 722 insertions(+), 1398 deletions(-) create mode 100644 Tests/GObjectGeneratorCoreTests/AsyncCallableTests.swift diff --git a/Sources/GObjectGeneratorCore/BindingPlan.swift b/Sources/GObjectGeneratorCore/BindingPlan.swift index 84e1bd8..e3bc7b0 100644 --- a/Sources/GObjectGeneratorCore/BindingPlan.swift +++ b/Sources/GObjectGeneratorCore/BindingPlan.swift @@ -363,6 +363,10 @@ public enum TypePlan: Sendable { case record(RecordPlan) /// A callable (function, method, or constructor). case callable(CallablePlan) + /// A GIO `*_async`/`*_finish` pair, rendered as one Swift `async` + /// method, at namespace level (paired ``s, not class/record/ + /// interface members — those live on `ClassPlan.asyncMethods` etc.). + case asyncCallable(AsyncCallablePlan) /// A namespace-level callback typealias. case callback(CallbackTypePlan) } @@ -583,6 +587,9 @@ public struct ClassPlan: Equatable, Sendable { public let signals: [SignalPlan] /// Module-qualified names of implemented interfaces (e.g. ["GObject.TypePlugin"]). public let interfaces: [String] + /// Planned GIO `*_async`/`*_finish` pairs, each rendered as one Swift + /// `async` method after `methods`. + public let asyncMethods: [AsyncCallablePlan] /// Documentation from the GIR `` element. public let doc: String? @@ -597,6 +604,7 @@ public struct ClassPlan: Equatable, Sendable { constructors: [CallablePlan] = [], methods: [CallablePlan] = [], functions: [CallablePlan] = [], properties: [PropertyPlan] = [], signals: [SignalPlan] = [], + asyncMethods: [AsyncCallablePlan] = [], doc: String? = nil) { self.name = name; self.girName = girName; self.cType = cType self.parent = parent; self.parentGIRName = parentGIRName @@ -609,6 +617,7 @@ public struct ClassPlan: Equatable, Sendable { self.constructors = constructors; self.methods = methods self.functions = functions; self.properties = properties self.signals = signals + self.asyncMethods = asyncMethods self.doc = doc } } @@ -631,12 +640,16 @@ public struct RecordPlan: Equatable, Sendable { public let methods: [CallablePlan] /// Static functions associated with the boxed record. public let functions: [CallablePlan] + /// Planned GIO `*_async`/`*_finish` pairs, each rendered as one Swift + /// `async` method after `methods`. + public let asyncMethods: [AsyncCallablePlan] public let doc: String? public init(name: String, cType: String, getTypeFunction: String? = nil, copyFunction: String? = nil, copyReturnsVoid: Bool = false, freeFunction: String? = nil, constructors: [CallablePlan] = [], methods: [CallablePlan] = [], functions: [CallablePlan] = [], + asyncMethods: [AsyncCallablePlan] = [], doc: String? = nil) { self.name = name; self.cType = cType self.getTypeFunction = getTypeFunction @@ -644,6 +657,7 @@ public struct RecordPlan: Equatable, Sendable { self.freeFunction = freeFunction self.constructors = constructors; self.methods = methods self.functions = functions + self.asyncMethods = asyncMethods self.doc = doc } } @@ -669,6 +683,9 @@ public struct InterfacePlan: Equatable, Sendable { public let properties: [PropertyPlan] /// Signals declared by this interface. public let signals: [SignalPlan] + /// Planned GIO `*_async`/`*_finish` pairs, rendered as default `async` + /// method implementations inside the protocol extension, after `methods`. + public let asyncMethods: [AsyncCallablePlan] /// The module-qualified Swift name, e.g. `"GObject.TypePlugin"`. /// Used to match against `ClassPlan.interfaces` entries. public let qualifiedName: String @@ -682,12 +699,14 @@ public struct InterfacePlan: Equatable, Sendable { classPrereq: String? = nil, getTypeFunction: String? = nil, methods: [CallablePlan] = [], properties: [PropertyPlan] = [], signals: [SignalPlan] = [], + asyncMethods: [AsyncCallablePlan] = [], qualifiedName: String = "", isGObject: Bool = true, doc: String? = nil) { self.name = name; self.cType = cType; self.prereqs = prereqs self.classPrereq = classPrereq self.getTypeFunction = getTypeFunction; self.methods = methods self.properties = properties; self.signals = signals + self.asyncMethods = asyncMethods self.qualifiedName = qualifiedName self.isGObject = isGObject self.doc = doc @@ -854,16 +873,51 @@ public struct ParameterPlan: Equatable, Sendable { /// When set, this C param is a synthesized array length (argc); its value is /// `.count` and it is omitted from the Swift signature. public let synthesizedLengthOf: String? + /// The `GAsyncReadyCallback`-protocol role of this parameter, or `nil` + /// for an ordinary parameter. Set only on the trailing callback/ + /// user-data pair of a GIO `*_async` starter; such parameters are + /// filled by the generated async bridge and omitted from the Swift + /// signature (see `swiftSignature`, `cArguments`). + public let asyncRole: AsyncParameterRole? public init(swiftName: String, cArgIndex: Int, mapping: Mapping, isInstanceParameter: Bool = false, isOutParameter: Bool = false, closureIndex: Int? = nil, destroyIndex: Int? = nil, - synthesizedLengthOf: String? = nil) { + synthesizedLengthOf: String? = nil, asyncRole: AsyncParameterRole? = nil) { self.swiftName = swiftName; self.cArgIndex = cArgIndex self.mapping = mapping; self.isInstanceParameter = isInstanceParameter self.isOutParameter = isOutParameter self.closureIndex = closureIndex; self.destroyIndex = destroyIndex self.synthesizedLengthOf = synthesizedLengthOf + self.asyncRole = asyncRole + } +} + +/// The role a C parameter plays in the `GAsyncReadyCallback` protocol of a +/// GIO async starter. Such parameters are filled by the generated bridge +/// and omitted from the Swift signature. +public enum AsyncParameterRole: Equatable, Sendable { + /// The `GAsyncReadyCallback` argument. + case callback + /// The callback's `user_data` argument. + case userData +} + +/// The plan for one GIO asynchronous operation: the `*_async` starter +/// paired with its `*_finish` completion, rendered as a single Swift +/// `async` method. +public struct AsyncCallablePlan: Equatable, Sendable { + /// The starter callable. Its callback and user-data parameters carry a + /// non-nil `asyncRole` and never appear in the Swift signature. + public let starter: CallablePlan + /// The paired `*_finish` callable, already planned on the same owner. + public let finish: CallablePlan + /// The Swift type qualifying `finish` when it is static; `nil` for + /// instance methods and namespace-level functions. + public let finishOwner: String? + + public init(starter: CallablePlan, finish: CallablePlan, finishOwner: String? = nil) { + self.starter = starter; self.finish = finish; self.finishOwner = finishOwner } } extension Mapping { diff --git a/Sources/GObjectGeneratorCore/PlanRenderer.swift b/Sources/GObjectGeneratorCore/PlanRenderer.swift index f76aed6..4b25101 100644 --- a/Sources/GObjectGeneratorCore/PlanRenderer.swift +++ b/Sources/GObjectGeneratorCore/PlanRenderer.swift @@ -51,6 +51,8 @@ public func renderModule(_ plan: ModulePlan) -> [String: String] { constants.append((p.name, renderConstant(p))) case .callable(let p): functions.append((p.name, renderCallable(p))) + case .asyncCallable(let p): + functions.append((p.starter.name, renderAsyncMethod(p, indent: "", isTopLevel: true).joined(separator: "\n") + "\n")) case .callback(let p): callbacks.append((p.name, renderCallbackType(p))) default: @@ -85,8 +87,19 @@ public func renderModule(_ plan: ModulePlan) -> [String: String] { } return false } + // Any owner with a bound GIO `*_async`/`*_finish` pair needs the async + // bridge (`_sgtkAwaitAsyncReady`) emitted into this module's Support.swift. + let hasAsyncCallables = plan.types.contains { typePlan in + switch typePlan { + case .class(let p): return !p.asyncMethods.isEmpty + case .record(let p): return !p.asyncMethods.isEmpty + case .interface(let p): return !p.asyncMethods.isEmpty + case .asyncCallable: return true + default: return false + } + } - files["Support.swift"] = renderSupport(moduleName: plan.module, dependencyModules: plan.dependencyModules, hasSignals: hasSignals, hasCallbackBoxes: hasCallbacks) + files["Support.swift"] = renderSupport(moduleName: plan.module, dependencyModules: plan.dependencyModules, hasSignals: hasSignals, hasCallbackBoxes: hasCallbacks, hasAsyncCallables: hasAsyncCallables) for filename in files.keys { precondition(isValidGeneratedFileName(filename), @@ -154,7 +167,7 @@ private func leadingNameWord(_ name: String) -> String { return word.isEmpty ? String(trimmed) : String(word) } -private func renderSupport(moduleName: String, dependencyModules: [String] = [], hasSignals: Bool = false, hasCallbackBoxes: Bool = false) -> String { +private func renderSupport(moduleName: String, dependencyModules: [String] = [], hasSignals: Bool = false, hasCallbackBoxes: Bool = false, hasAsyncCallables: Bool = false) -> String { let glibError: String if moduleName == "GLib" { glibError = """ @@ -303,6 +316,62 @@ private func renderSupport(moduleName: String, dependencyModules: [String] = [], primitiveShims = "" } + let asyncSupport: String + if hasAsyncCallables { + asyncSupport = """ + + // MARK: - GIO async/await bridge + + /// Boxes the continuation awaiting a GIO `*_async` operation. + @MainActor + final class _AsyncReadyBox { + let continuation: CheckedContinuation + init(_ continuation: CheckedContinuation) { + self.continuation = continuation + } + } + + /// The single `GAsyncReadyCallback` every generated `async` method hands to C. + /// + /// GIO invokes it on the thread-default main context - the main thread for + /// these libraries - so `MainActor.assumeIsolated` is sound, exactly as in the + /// signal trampolines. The `GAsyncResult` is only guaranteed to live for the + /// duration of this call, and resuming a continuation merely schedules the + /// awaiting job, so the result is retained here and released by the awaiting + /// method once `*_finish` has run. The `nonisolated(unsafe)` shadow copies + /// below are the same documented-safe pattern the signal trampolines use: + /// the C parameters belong to this `nonisolated` closure's isolation domain, + /// and Swift 6's region-based sending checker flags capturing them directly + /// into the `@MainActor` closure as a potential data race even though both + /// values are only ever touched here, once, on the main thread. + private let _sgtkAsyncReadyCallback: GAsyncReadyCallback = { _, result, data in + guard let result, let data else { return } + nonisolated(unsafe) let capturedResult = UnsafeMutableRawPointer(result) + nonisolated(unsafe) let box = Unmanaged<_AsyncReadyBox>.fromOpaque(data).takeRetainedValue() + MainActor.assumeIsolated { + g_object_ref(capturedResult) + box.continuation.resume(returning: capturedResult) + } + } + + /// Runs a GIO `*_async` starter and suspends until its callback fires. + /// + /// - Parameter start: Invokes the C starter, passing through the callback and + /// user-data arguments this helper supplies. + /// - Returns: An owned `GAsyncResult` pointer the caller must `g_object_unref`. + func _sgtkAwaitAsyncReady( + _ start: (GAsyncReadyCallback, UnsafeMutableRawPointer) -> Void + ) async -> UnsafeMutableRawPointer { + await withCheckedContinuation { continuation in + let box = _AsyncReadyBox(continuation) + start(_sgtkAsyncReadyCallback, Unmanaged.passRetained(box).toOpaque()) + } + } + """ + } else { + asyncSupport = "" + } + let depImports = dependencyModules.map { "@_spi(SGTKInternal) import \($0)\n" }.joined() return """ // Generated by gobject-generator. DO NOT EDIT. @@ -430,7 +499,7 @@ private func renderSupport(moduleName: String, dependencyModules: [String] = [], return try copy.withUnsafeMutableBufferPointer { try body($0.baseAddress) } } - \(glibError)\(gtypeConstants)\(closureBoxSupport)\(signalSupport)\(primitiveShims) + \(glibError)\(gtypeConstants)\(closureBoxSupport)\(signalSupport)\(primitiveShims)\(asyncSupport) """ } @@ -450,6 +519,8 @@ private func renderTypePlan(_ typePlan: TypePlan) -> (String, String) { case .interface(let p): return (p.name, renderInterface(p)) case .record(let p): return (p.name, renderRecord(p)) case .callable(let p): return (p.name, renderCallable(p)) + case .asyncCallable(let p): + return (p.starter.name, renderAsyncMethod(p, indent: "", isTopLevel: true).joined(separator: "\n") + "\n") case .callback(let p): return (p.name, renderCallbackType(p)) } } @@ -663,6 +734,10 @@ private func renderRecord(_ plan: RecordPlan) -> String { lines.append(contentsOf: renderMethod(method)) lines.append("") } + for asyncMethod in plan.asyncMethods { + lines.append(contentsOf: renderAsyncMethod(asyncMethod, indent: " ")) + lines.append("") + } for fn in plan.functions { lines.append(contentsOf: renderStaticFunction(fn)) lines.append("") @@ -701,13 +776,17 @@ private func renderInterface(_ plan: InterfacePlan) -> String { // working implementation via `self.pointer` for free, and no // requirement can go unwitnessed (a class's own member of the same // name still wins by static dispatch specificity where it exists). - if !plan.methods.isEmpty || !plan.properties.isEmpty || !plan.signals.isEmpty { + if !plan.methods.isEmpty || !plan.asyncMethods.isEmpty || !plan.properties.isEmpty || !plan.signals.isEmpty { lines.append("") lines.append("extension \(plan.name) {") for method in plan.methods { lines.append(contentsOf: renderMethod(method)) lines.append("") } + for asyncMethod in plan.asyncMethods { + lines.append(contentsOf: renderAsyncMethod(asyncMethod, indent: " ")) + lines.append("") + } for prop in plan.properties { lines.append(contentsOf: renderProperty(prop)) lines.append("") @@ -859,6 +938,10 @@ private func renderClass(_ plan: ClassPlan) -> String { lines.append(contentsOf: renderMethod(method)) lines.append("") } + for asyncMethod in plan.asyncMethods { + lines.append(contentsOf: renderAsyncMethod(asyncMethod, indent: " ")) + lines.append("") + } for fn in plan.functions { lines.append(contentsOf: renderStaticFunction(fn)) lines.append("") @@ -1149,7 +1232,7 @@ private func renderSignalConnect(_ plan: SignalPlan, className: String) -> [Stri return lines } private func swiftSignature(_ plan: CallablePlan) -> String { - plan.parameters.filter { !$0.isInstanceParameter && !$0.isOutParameter && $0.synthesizedLengthOf == nil }.map { param in + plan.parameters.filter { !$0.isInstanceParameter && !$0.isOutParameter && $0.synthesizedLengthOf == nil && $0.asyncRole == nil }.map { param in let typeStr: String if param.mapping.category == .callback { typeStr = "@escaping \(param.mapping.swiftType)" @@ -1228,6 +1311,10 @@ private func cArguments(_ plan: CallablePlan, error: Bool = false) -> (cCall: St let cName = "cArray\(stringParams.count)" stringParams.append((cName: cName, swiftName: param.swiftName, kind: kind)) cArgExprs.append(cName) + } else if param.asyncRole == .callback { + cArgExprs.append("_asyncCallback") + } else if param.asyncRole == .userData { + cArgExprs.append("_asyncUserData") } else if let dataPtrName = closureDataMap[param.cArgIndex], !isCallbackBox(param) { cArgExprs.append(dataPtrName) } else { @@ -1609,6 +1696,49 @@ private func hasOutParams(_ plan: CallablePlan) -> Bool { plan.parameters.contains(where: \.isOutParameter) } +/// Renders one GIO `*_async`/`*_finish` pair as a single Swift `async` +/// method. Modeled on `renderMethod`/`renderStaticFunction`/`renderCallable` +/// - the trailing `GAsyncReadyCallback`/`user_data` pair is bridged through +/// `_sgtkAwaitAsyncReady`, and the result is unpacked via the `*_finish` +/// sibling, already planned on the same owner. +/// +/// - Parameters: +/// - plan: The starter/finish pair. +/// - indent: `""` for a top-level free function, `" "` for a class/ +/// record method or an interface protocol-extension default. +/// - isTopLevel: `true` suppresses the `static` keyword — free functions +/// are never `static` in Swift even though `CallablePlan.isStatic` is +/// `true` for them (see `planFunction`). +private func renderAsyncMethod(_ plan: AsyncCallablePlan, indent: String, isTopLevel: Bool = false) -> [String] { + var lines: [String] = [] + if let doc = plan.starter.doc { + lines.append(contentsOf: renderDocComment(doc).map { indent.isEmpty ? $0 : "\(indent)\($0)" }) + } + let staticKeyword = (!isTopLevel && plan.starter.isStatic) ? "static " : "" + let throwsKeyword = plan.finish.throwsError ? " throws" : "" + let retType = callableReturnType(plan.finish) ?? "" + let hidden = signatureHasRawPointer(plan.starter) || signatureHasRawPointer(plan.finish) + lines.append("\(indent)\(spiPrefix(hidden))public \(staticKeyword)func \(plan.starter.name)(\(swiftSignature(plan.starter))) async\(throwsKeyword)\(retType) {") + + let bodyIndent = indent + " " + lines.append("\(bodyIndent)let _asyncResult = await _sgtkAwaitAsyncReady { _asyncCallback, _asyncUserData in") + lines.append(contentsOf: renderCallBody(plan.starter, indent: bodyIndent + " ")) + lines.append("\(bodyIndent)}") + lines.append("\(bodyIndent)defer { g_object_unref(_asyncResult) }") + + // Rule 3 (the recognizer) guarantees exactly one such parameter exists. + let finishResultParam = plan.finish.parameters.first { + !$0.isInstanceParameter && !$0.isOutParameter && $0.synthesizedLengthOf == nil + } + let ownerPrefix = plan.finishOwner.map { "\($0)." } ?? "" + let tryKeyword = plan.finish.throwsError ? "try " : "" + let returnKeyword = callableReturnType(plan.finish) != nil ? "return " : "" + let resultArg = finishResultParam.map { "\($0.swiftName): AsyncResultRef(retaining: _asyncResult)" } ?? "" + lines.append("\(bodyIndent)\(returnKeyword)\(tryKeyword)\(ownerPrefix)\(plan.finish.name)(\(resultArg))") + lines.append("\(indent)}") + return lines +} + // MARK: - Callable renderers private func renderCallable(_ plan: CallablePlan) -> String { diff --git a/Sources/GObjectGeneratorCore/Planner.swift b/Sources/GObjectGeneratorCore/Planner.swift index e91d186..7f39afa 100644 --- a/Sources/GObjectGeneratorCore/Planner.swift +++ b/Sources/GObjectGeneratorCore/Planner.swift @@ -83,6 +83,19 @@ public func planModules( return "\(m.name)|throws:\(m.throwsError)|(\(params))" } + // Same idea, but for an async method's rendered signature: the starter + // carries the real parameter list (minus its synthesized callback/ + // user-data pair, which never appears in the Swift signature) while + // whether the call `throws` comes from the paired `*_finish` callable, + // not the always-non-throwing void starter. + func asyncMethodSignature(_ p: AsyncCallablePlan) -> String { + let params = p.starter.parameters + .filter { !$0.isInstanceParameter && !$0.isOutParameter && $0.synthesizedLengthOf == nil && $0.asyncRole == nil } + .map { "\($0.swiftName):\($0.mapping.swiftType)" } + .joined(separator: ",") + return "\(p.starter.name)|throws:\(p.finish.throwsError)|(\(params))" + } + // Walked by GIR name, not Swift spelling: two classes in different // modules can share a Swift simple name (`Gst.Object` / `GObject.Object` // both spell `Object`), which would make a bare-name-keyed walk and its @@ -98,6 +111,7 @@ public func planModules( seen.insert(parentGIRName) propNames.formUnion(parentPlan.properties.map(\.swiftName)) methodSigs.formUnion(parentPlan.methods.map(methodSignature)) + methodSigs.formUnion(parentPlan.asyncMethods.map(asyncMethodSignature)) current = parentPlan.parentGIRName } return (propNames, methodSigs) @@ -118,6 +132,13 @@ public func planModules( detail: "method '\(method.name)' already declared by ancestor")) return false } + let filteredAsyncMethods = plan.asyncMethods.filter { asyncMethod in + guard inherited.methods.contains(asyncMethodSignature(asyncMethod)) else { return true } + skips.append(SkipEntry(symbol: "\(moduleName).\(plan.name).\(asyncMethod.starter.name)", + cIdentifier: asyncMethod.starter.cIdentifier, reason: .inheritedMember, + detail: "async method '\(asyncMethod.starter.name)' already declared by ancestor")) + return false + } // Own-method selectors that survived filtering — used below to // catch properties left delegating to a method this pass just // removed (the property was planned before this global pass ran, @@ -150,7 +171,8 @@ public func planModules( } return true } - guard filteredProps.count != plan.properties.count || filteredMethods.count != plan.methods.count else { + guard filteredProps.count != plan.properties.count || filteredMethods.count != plan.methods.count + || filteredAsyncMethods.count != plan.asyncMethods.count else { return typePlan } changed = true @@ -165,7 +187,7 @@ public func planModules( interfaces: plan.interfaces, constructors: plan.constructors, methods: filteredMethods, functions: plan.functions, properties: filteredProps, - signals: plan.signals, doc: plan.doc + signals: plan.signals, asyncMethods: filteredAsyncMethods, doc: plan.doc ) return .class(newPlan) } @@ -274,6 +296,27 @@ private func planNamespace(_ ns: Namespace, context: MapContext) -> ModulePlan { boundCallables += planOrSkipFunction(into: &skips, into: &types, fn: fn, namespace: ns.name, context: context) } + // ── GIO async pattern (namespace-level functions) ── + // Excludes `moved-to` functions: those are routed into an owning + // class/record's own `functions` list above, and that owner's + // `planClass`/`planRecord` already ran its own async pairing pass over + // its GIR-declared ``s before the routing happened. + let namespaceAsyncCandidates = ns.functions + .filter { $0.symbolInfo.isBindable && $0.symbolInfo.movedTo == nil } + .map { AsyncStarterCandidate(name: $0.name, cIdentifier: $0.cIdentifier, parameters: $0.parameters, doc: $0.doc) } + let plannedFunctions: [CallablePlan] = types.compactMap { + if case .callable(let p) = $0 { return p } + return nil + } + let namespaceAsyncPairs = planAsyncPairs( + candidates: namespaceAsyncCandidates, planned: plannedFunctions, + isStatic: true, fullNamePrefix: ns.name, context: context) + if !namespaceAsyncPairs.isEmpty { + removeStaleAsyncSkips(&skips, for: namespaceAsyncPairs) + types.append(contentsOf: namespaceAsyncPairs.map { .asyncCallable($0) }) + boundCallables += namespaceAsyncPairs.count + } + // ── Cross-category name collision detection ── // Constants and functions can case-fold to the same Swift name // (e.g. ATOMIC_REF_COUNT_INIT and g_atomic_ref_count_init both map to @@ -431,6 +474,154 @@ private func dedupBySignature( return result } +// MARK: - GIO async pattern + +/// One raw candidate for GIO `*_async`/`*_finish` pairing: a method or +/// global function whose GIR name ends `_async`. Built by each caller from +/// its owner's raw, bindable `Method`/`GlobalFunction` list — mirrors the +/// `where symbolInfo.isBindable` filter the ordinary planning loops apply. +private struct AsyncStarterCandidate { + let name: String + let cIdentifier: String + let parameters: [Parameter] + let doc: String? +} + +/// Pairs GIO-style `*_async` starters with their `*_finish` completions so +/// the renderer can emit one Swift `async` method per operation. +/// +/// A starter qualifies only when every rule holds; otherwise it produces no +/// pair. The caller still runs the normal `planMethod`/`planFunction` path +/// on every raw candidate regardless (this function never mutates that +/// path's inputs), so a starter that fails a rule here falls through to the +/// existing D4.3 `callbackWithoutUserData` skip unchanged — no baseline +/// entry moves to a new reason. For starters that DO pair successfully, the +/// caller is responsible for dropping that now-stale skip entry (matched by +/// `cIdentifier`) from its own skip list, since this function only adds. +/// +/// 1. (Pre-filtered by the caller via the GIR name.) The starter's GIR name +/// and C identifier both end `_async`. +/// 2. The last two parameters are, in order, a parameter whose resolved +/// type is `Gio.AsyncReadyCallback` and a bare `gpointer` (the +/// conventional trailing `user_data`). Any other shape disqualifies the +/// starter. Checked structurally (position + type) rather than via the +/// GIR `closure=` attribute, whose indexing is relative to `` +/// children only (excluding ``) and would need a +/// separate, error-prone offset to compare against this array's indices. +/// 3. A sibling callable named `swiftFunctionName(_finish)` is +/// already in `planned` (found by C identifier: the starter's +/// `cIdentifier` with its `_async` suffix replaced by `_finish`), and it +/// takes exactly one non-instance, non-out, non-synthesized parameter +/// whose `mapping.swiftType == "AsyncResult"`. +/// 4. No callable already in `planned` uses the starter's Swift name. +/// 5. The starter's remaining parameters (everything but the trailing +/// callback/user-data pair) all plan through the normal path. +/// 6. The current module is `Gio` or depends on it — the rendered bridge +/// references `Gio.AsyncResultRef`. +/// +/// - Parameters: +/// - candidates: Every raw method/function whose GIR name ends `_async`. +/// - planned: The owner's already-planned sibling callables (methods and +/// functions together), searched for the `*_finish` completion. +/// - isStatic: Whether the starter renders as a `static`/free function +/// (record/class functions, namespace-level functions) or an instance +/// method. +/// - fullNamePrefix: `""` or `"."`, used to +/// build the fully qualified GIR symbol name passed to `planCallable`. +/// - ownerSwiftName: The owner's unqualified Swift type name (e.g. +/// `"IOStream"`), used to qualify the `*_finish` call when it plans as +/// `static` (GIR sometimes declares the completion as a bare +/// `` with no instance parameter, e.g. +/// `g_io_stream_splice_finish`, even though its starter is an instance +/// method) — an unqualified call to a static sibling from an instance +/// method body does not compile. `nil` for namespace-level pairs, whose +/// `*_finish` is already a free function reachable unqualified. +/// - context: The resolution context. +/// - Returns: One `AsyncCallablePlan` per starter that satisfies every rule. +private func planAsyncPairs( + candidates: [AsyncStarterCandidate], + planned: [CallablePlan], + isStatic: Bool, + fullNamePrefix: String, + ownerSwiftName: String? = nil, + context: MapContext +) -> [AsyncCallablePlan] { + guard context.currentModule == "Gio" || context.dependencyModules.contains("Gio") else { return [] } + guard !candidates.isEmpty else { return [] } + + var plannedNames = Set(planned.map(\.name)) + var results: [AsyncCallablePlan] = [] + + for candidate in candidates { + guard candidate.name.hasSuffix("_async"), candidate.cIdentifier.hasSuffix("_async") else { continue } + guard candidate.parameters.count >= 2 else { continue } + + // Rule 2. + let calleeParam = candidate.parameters[candidate.parameters.count - 2] + let userDataParam = candidate.parameters[candidate.parameters.count - 1] + guard userDataParam.type == .pointer else { continue } + guard case .typeRef(let cbName, let cbNamespace) = calleeParam.type else { continue } + guard cbName == "AsyncReadyCallback", (cbNamespace ?? context.currentNamespace) == "Gio" else { continue } + + // Rule 4. + let starterName = swiftFunctionName(candidate.name) + guard !plannedNames.contains(starterName) else { continue } + + // Rule 3. + let finishCIdentifier = String(candidate.cIdentifier.dropLast("_async".count)) + "_finish" + guard let finishPlan = planned.first(where: { $0.cIdentifier == finishCIdentifier }) else { continue } + let finishRealParams = finishPlan.parameters.filter { + !$0.isInstanceParameter && !$0.isOutParameter && $0.synthesizedLengthOf == nil + } + guard finishRealParams.count == 1, finishRealParams[0].mapping.swiftType == "AsyncResult" else { continue } + + // Rule 5: plan the starter with the trailing callback/user-data + // pair dropped, through the exact same path an ordinary method or + // function uses (so every other marshalling rule still applies). + let trimmedParams = Array(candidate.parameters.dropLast(2)) + let starterResult = planCallable( + fullName: "\(fullNamePrefix).\(candidate.name)", swiftName: starterName, + cIdentifier: candidate.cIdentifier, parameters: trimmedParams, + returnValue: ReturnValue(), throwsGError: false, + doc: candidate.doc, isStatic: isStatic, context: context) + guard case .success(let trimmedPlan) = starterResult else { continue } + + // Re-append the callback/user-data pair, marked with their async + // role so the renderer omits them from the Swift signature and + // fills them from the generated bridge instead. Trailing position + // in this array reproduces their trailing position in the C + // argument list (`cArguments` builds the call in array order). + let placeholder = Mapping(swiftType: "", cSwiftType: "", marshalIn: .direct, marshalOut: .direct) + let starterPlan = CallablePlan( + name: trimmedPlan.name, cIdentifier: trimmedPlan.cIdentifier, + parameters: trimmedPlan.parameters + [ + ParameterPlan(swiftName: "_asyncCallback", cArgIndex: candidate.parameters.count - 2, + mapping: placeholder, asyncRole: .callback), + ParameterPlan(swiftName: "_asyncUserData", cArgIndex: candidate.parameters.count - 1, + mapping: placeholder, asyncRole: .userData), + ], + returnMapping: trimmedPlan.returnMapping, isStatic: trimmedPlan.isStatic, + isConstructor: false, ownershipInit: nil, throwsError: trimmedPlan.throwsError, + isOverride: false, doc: trimmedPlan.doc) + + plannedNames.insert(starterName) + results.append(AsyncCallablePlan( + starter: starterPlan, finish: finishPlan, + finishOwner: finishPlan.isStatic ? ownerSwiftName : nil)) + } + return results +} + +/// Drops skip entries for starters that `planAsyncPairs` successfully +/// bound, so the skip report reflects the pairing rather than the stale +/// per-parameter D4.3 failure the ordinary planning path also recorded for +/// the same raw candidate. +private func removeStaleAsyncSkips(_ skips: inout [SkipEntry], for asyncMethods: [AsyncCallablePlan]) { + guard !asyncMethods.isEmpty else { return } + let paired = Set(asyncMethods.map(\.starter.cIdentifier)) + skips.removeAll { entry in entry.cIdentifier.map(paired.contains) ?? false } +} + // MARK: - Per-category planning (returns 1 for bound, 0 for skipped) private func planEnum( @@ -518,7 +709,7 @@ private func skipClass( } let (plan, memberSkips) = planClass(klass, context: context) skips.append(contentsOf: memberSkips) - boundCallables += plan.constructors.count + plan.methods.count + plan.functions.count + boundCallables += plan.constructors.count + plan.methods.count + plan.functions.count + plan.asyncMethods.count types.append(.class(plan)) return 1 } @@ -557,7 +748,7 @@ private func skipRecord( } let (plan, memberSkips) = planRecord(record, context: context) skips.append(contentsOf: memberSkips) - boundCallables += plan.constructors.count + plan.methods.count + plan.functions.count + boundCallables += plan.constructors.count + plan.methods.count + plan.functions.count + plan.asyncMethods.count types.append(.record(plan)) return 1 } @@ -663,7 +854,7 @@ private func planOrSkipFunction(into skips: inout [SkipEntry], into types: inout copyReturnsVoid: recordPlan.copyReturnsVoid, freeFunction: recordPlan.freeFunction, constructors: recordPlan.constructors, methods: recordPlan.methods, - functions: functions, doc: recordPlan.doc)) + functions: functions, asyncMethods: recordPlan.asyncMethods, doc: recordPlan.doc)) case .class(let classPlan): var functions = classPlan.functions if functions.contains(where: { $0.cIdentifier == routed.cIdentifier }) { @@ -682,7 +873,7 @@ private func planOrSkipFunction(into skips: inout [SkipEntry], into types: inout interfaces: classPlan.interfaces, constructors: classPlan.constructors, methods: classPlan.methods, functions: functions, properties: classPlan.properties, signals: classPlan.signals, - doc: classPlan.doc)) + asyncMethods: classPlan.asyncMethods, doc: classPlan.doc)) default: fatalError("moved-to target changed while routing") } @@ -791,12 +982,28 @@ func planRecord(_ record: Record, context: MapContext) -> (plan: RecordPlan, mem functionPlans = dedupBySignature(functionPlans, isConstructor: false, symbolPrefix: girName, skips: &memberSkips) + // ── GIO async pattern ── + let allOwnerPlans = methodPlans + functionPlans + let methodAsyncPairs = planAsyncPairs( + candidates: record.methods.filter { $0.symbolInfo.isBindable && !["free", "unref"].contains($0.name) }.map { + AsyncStarterCandidate(name: $0.name, cIdentifier: $0.cIdentifier, parameters: $0.parameters, doc: $0.doc) + }, + planned: allOwnerPlans, isStatic: false, fullNamePrefix: girName, ownerSwiftName: record.name, context: context) + let functionAsyncPairs = planAsyncPairs( + candidates: record.functions.filter(\.symbolInfo.isBindable).map { + AsyncStarterCandidate(name: $0.name, cIdentifier: $0.cIdentifier, parameters: $0.parameters, doc: $0.doc) + }, + planned: allOwnerPlans, isStatic: true, fullNamePrefix: girName, ownerSwiftName: record.name, context: context) + let asyncMethods = methodAsyncPairs + functionAsyncPairs + removeStaleAsyncSkips(&memberSkips, for: asyncMethods) + let plan = RecordPlan( name: record.name, cType: record.cType, getTypeFunction: record.getTypeFunction, copyFunction: pair.copy, copyReturnsVoid: pair.copyReturnsVoid, freeFunction: pair.free, constructors: constructorPlans, methods: methodPlans, functions: functionPlans, + asyncMethods: asyncMethods, doc: record.doc ) return (plan, memberSkips) @@ -921,6 +1128,15 @@ func planInterface(_ iface: Interface, context: MapContext) -> (plan: InterfaceP } } + // ── GIO async pattern ── + let ifaceGirName = "\(context.currentNamespace).\(iface.name)" + let asyncMethods = planAsyncPairs( + candidates: iface.methods.filter(\.symbolInfo.isBindable).map { + AsyncStarterCandidate(name: $0.name, cIdentifier: $0.cIdentifier, parameters: $0.parameters, doc: $0.doc) + }, + planned: methodPlans, isStatic: false, fullNamePrefix: ifaceGirName, context: context) + removeStaleAsyncSkips(&memberSkips, for: asyncMethods) + // ── Properties ── // Interfaces publish properties as `{ get }` / `{ get set }` requirements, // not bodies, so there is nothing to delegate to — the conforming class @@ -961,6 +1177,7 @@ func planInterface(_ iface: Interface, context: MapContext) -> (plan: InterfaceP methods: methodPlans, properties: propertyPlans, signals: signalPlans, + asyncMethods: asyncMethods, qualifiedName: qualifiedName, doc: iface.doc ) @@ -1163,6 +1380,24 @@ func planClass(_ klass: Class, context: MapContext) -> (plan: ClassPlan, memberS collect(planFunction(fn, context: context), into: &functionPlans) } + // ── GIO async pattern ── + // Runs once ordinary methods/functions are planned, so a `*_finish` + // sibling declared later in `klass.methods`/`klass.functions` is + // already available for rule 3 to match against. + let allOwnerPlans = methodPlans + functionPlans + let methodAsyncPairs = planAsyncPairs( + candidates: klass.methods.filter(\.symbolInfo.isBindable).map { + AsyncStarterCandidate(name: $0.name, cIdentifier: $0.cIdentifier, parameters: $0.parameters, doc: $0.doc) + }, + planned: allOwnerPlans, isStatic: false, fullNamePrefix: girName, ownerSwiftName: klass.name, context: context) + let functionAsyncPairs = planAsyncPairs( + candidates: klass.functions.filter(\.symbolInfo.isBindable).map { + AsyncStarterCandidate(name: $0.name, cIdentifier: $0.cIdentifier, parameters: $0.parameters, doc: $0.doc) + }, + planned: allOwnerPlans, isStatic: true, fullNamePrefix: girName, ownerSwiftName: klass.name, context: context) + let asyncMethods = methodAsyncPairs + functionAsyncPairs + removeStaleAsyncSkips(&memberSkips, for: asyncMethods) + // ── Properties ── // Pass the planned methods so accessors can delegate to a `getter=`/ // `setter=` method when GIR names one and it was itself successfully planned. @@ -1215,6 +1450,7 @@ func planClass(_ klass: Class, context: MapContext) -> (plan: ClassPlan, memberS functions: functionPlans, properties: propertyPlans, signals: signalPlans, + asyncMethods: asyncMethods, doc: klass.doc ) return (plan, memberSkips) diff --git a/Sources/GObjectGeneratorCore/TypeMapper.swift b/Sources/GObjectGeneratorCore/TypeMapper.swift index fc1fdfb..e951796 100644 --- a/Sources/GObjectGeneratorCore/TypeMapper.swift +++ b/Sources/GObjectGeneratorCore/TypeMapper.swift @@ -195,6 +195,17 @@ public func mapArrayParameter( case .int8, .int16, .int32, .uint8, .uint16, .uint32, .char, .uchar, .unichar, .float, .double: + // A transfer-full scalar buffer is consumed (and typically freed) + // by the callee. The `_withScalarArray` bridge only lends a pointer + // into a temporary Swift copy for the duration of the call, so a + // callee that frees or retains that pointer past the call (e.g. + // `g_bytes_new_take`) would corrupt memory. No supported bridging + // shape exists for a consumed scalar buffer — reject rather than + // guess. + guard transfer != .full else { + throw MapError(reason: .arrayBridgingUnimplemented, + detail: "scalar array with transfer-ownership=full") + } guard info.lengthParameterIndex != nil else { throw MapError(reason: .arrayBridgingUnimplemented, detail: "scalar array has no length parameter") @@ -466,6 +477,24 @@ private func mapTypeRef( throw MapError(reason: .unknownType, detail: "callback '\(girName)' not found in registry") } + // A callback's own parameter/return types are spelled relative to + // ITS declaring namespace (e.g. Gio.AsyncReadyCallback's bare `res` + // param resolves against Gio), not the namespace of the call site + // referencing the callback (e.g. Gdk, when a Gdk method takes a + // Gio.AsyncReadyCallback parameter). `context.currentNamespace` + // stays pointed at the call site, so unqualified names inside the + // callback's own signature would otherwise resolve into the wrong + // namespace. Root a fresh context at the callback's declaring + // namespace (from `resolved.girName`, authoritative) while keeping + // `currentModule` unchanged so `swiftTypeName` still qualifies + // cross-module references relative to the consuming module. + let declaringNamespace = String(resolved.girName.prefix(while: { $0 != "." })) + let callbackContext = declaringNamespace == context.currentNamespace + ? context + : MapContext(registry: context.registry, + currentModule: context.currentModule, + currentNamespace: declaringNamespace, + dependencyModules: context.dependencyModules) // Split real parameters from the trailing user-data pointer let userDataIdx = cb.userDataParameterIndex let realParams: [Parameter] @@ -474,13 +503,12 @@ private func mapTypeRef( } else { realParams = cb.parameters } - // Map each real parameter var swiftParamTypes: [String] = [] var cSwiftParamTypes: [String] = [] for param in realParams { let pm: Mapping do { - pm = try _mapValue(type: param.type, transfer: param.transferOwnership, context: context, seen: seen) + pm = try _mapValue(type: param.type, transfer: param.transferOwnership, context: callbackContext, seen: seen) } catch { throw MapError(reason: .callbackWithoutUserData, detail: "callback '\(name)' param '\(param.name)' unmappable: \(error.detail)") @@ -497,7 +525,7 @@ private func mapTypeRef( var retSwiftType = "Void" if cb.returnValue.type != .void { do { - retMapping = try _mapValue(type: cb.returnValue.type, transfer: cb.returnValue.transferOwnership, context: context, seen: seen) + retMapping = try _mapValue(type: cb.returnValue.type, transfer: cb.returnValue.transferOwnership, context: callbackContext, seen: seen) } catch { throw MapError(reason: .callbackWithoutUserData, detail: "callback '\(name)' return unmappable: \(error.detail)") diff --git a/Tests/GObjectGeneratorCoreTests/AsyncCallableTests.swift b/Tests/GObjectGeneratorCoreTests/AsyncCallableTests.swift new file mode 100644 index 0000000..4444489 --- /dev/null +++ b/Tests/GObjectGeneratorCoreTests/AsyncCallableTests.swift @@ -0,0 +1,146 @@ +// AsyncCallableTests.swift +// Covers the GIO async pattern binding: `planAsyncPairs` recognizing a +// `*_async`/`*_finish` pair and `renderAsyncMethod` emitting the paired +// Swift `async` method. Mirrors `CallbackGenerationTests.swift`'s style — +// exercising the planner through its public entry points and the renderer +// through `renderModule`'s public file output. + +import Testing + +@testable import GObjectGeneratorCore + +@Suite("GIO async pattern") +struct AsyncCallableTests { + + // MARK: - Fixture + + /// A minimal `Gio`-module fixture: an `AsyncResult` class, a `Widget` + /// class with one properly-shaped `foo_async`/`foo_finish` pair, and + /// the `Gio.AsyncReadyCallback` callback type the pair's starter uses. + /// Modeled entirely inside "Gio" itself (rather than a separate + /// dependent module) so rule 6 (`currentModule == "Gio"`) is satisfied + /// trivially, keeping the fixture minimal. + func makeFooAsyncClass(includeFinish: Bool = true) -> Class { + var methods = [ + Method( + name: "foo_async", cIdentifier: "g_widget_foo_async", + parameters: [ + Parameter(name: "self", type: .typeRef("Widget"), isInstanceParameter: true), + Parameter(name: "callback", type: .typeRef("AsyncReadyCallback", namespace: "Gio"), + cType: "GAsyncReadyCallback", isNullable: true), + Parameter(name: "user_data", type: .pointer, cType: "gpointer", isNullable: true), + ], + returnValue: ReturnValue() + ), + ] + if includeFinish { + methods.append(Method( + name: "foo_finish", cIdentifier: "g_widget_foo_finish", + parameters: [ + Parameter(name: "self", type: .typeRef("Widget"), isInstanceParameter: true), + Parameter(name: "result", type: .typeRef("AsyncResult", namespace: "Gio"), cType: "GAsyncResult*"), + ], + returnValue: ReturnValue(type: .boolean), + throwsGError: true + )) + } + return Class(name: "Widget", cType: "GWidget", parent: nil, + getTypeFunction: "g_widget_get_type", methods: methods) + } + + func makeContext(includeFinish: Bool = true) -> (context: MapContext, klass: Class) { + let klass = makeFooAsyncClass(includeFinish: includeFinish) + let gio = Repository(namespaces: [ + Namespace( + name: "Gio", version: "2.0", + classes: [ + Class(name: "AsyncResult", cType: "GAsyncResult", parent: nil, + getTypeFunction: "g_async_result_get_type"), + klass, + ], + callbacks: [Callback( + name: "AsyncReadyCallback", cType: "GAsyncReadyCallback", + parameters: [ + Parameter(name: "source_object", type: .pointer, cType: "gpointer", isNullable: true), + Parameter(name: "res", type: .typeRef("AsyncResult"), cType: "GAsyncResult*"), + Parameter(name: "data", type: .pointer, cType: "gpointer", isNullable: true), + ] + )] + ) + ]) + let registry = TypeRegistry(repositories: ["Gio": gio]) + let context = MapContext(registry: registry, currentModule: "Gio", currentNamespace: "Gio") + return (context, klass) + } + + // MARK: - Recognizer + + @Test("A parsed foo_async + foo_finish pair produces one AsyncCallablePlan, and the starter's asyncRole parameters are the last two") + func fooAsyncFooFinishProducesOnePair() throws { + let (context, klass) = makeContext() + let (plan, memberSkips) = planClass(klass, context: context) + + #expect(plan.asyncMethods.count == 1) + let pair = try #require(plan.asyncMethods.first) + #expect(pair.starter.name == "fooAsync") + #expect(pair.finish.name == "fooFinish") + + // The starter's Swift-facing signature carries no callback/user-data + // parameters — only the async-role pair, trailing. + let realParams = pair.starter.parameters.filter { !$0.isInstanceParameter } + #expect(realParams.count == 2) + #expect(realParams[0].asyncRole == .callback) + #expect(realParams[1].asyncRole == .userData) + + // No callable reaches methodPlans still skipped for the callback param. + #expect(!plan.methods.contains { $0.name == "fooAsync" }) + #expect(plan.methods.contains { $0.name == "fooFinish" }) + + // The stale D4.3 skip for the paired starter was dropped. + #expect(!memberSkips.contains { $0.cIdentifier == "g_widget_foo_async" }) + } + + @Test("foo_async with no foo_finish produces no pair and keeps its callbackWithoutUserData skip") + func fooAsyncWithoutFinishStaysSkipped() throws { + let (context, klass) = makeContext(includeFinish: false) + let (plan, memberSkips) = planClass(klass, context: context) + + #expect(plan.asyncMethods.isEmpty) + #expect(!plan.methods.contains { $0.name == "fooAsync" }) + let skip = try #require(memberSkips.first { $0.cIdentifier == "g_widget_foo_async" }) + #expect(skip.reason == .callbackWithoutUserData) + } + + // MARK: - Renderer + + @Test("renderAsyncMethod output contains async throws, _sgtkAwaitAsyncReady, defer g_object_unref, and AsyncResultRef(retaining:)") + func renderedAsyncMethodContainsExpectedFragments() throws { + let (context, klass) = makeContext() + let (plan, _) = planClass(klass, context: context) + let module = ModulePlan(module: "Gio", types: [.class(plan)], skips: [], coverage: CoverageStats()) + let files = renderModule(module) + let source = try #require(files["Widget.swift"]) + + #expect(source.contains("public func fooAsync(") ) + #expect(source.contains(") async throws")) + #expect(source.contains("_sgtkAwaitAsyncReady")) + #expect(source.contains("defer { g_object_unref(")) + #expect(source.contains("AsyncResultRef(retaining:")) + #expect(source.contains("try fooFinish(result:")) + } + + @Test("swiftSignature for a starter omits the callback and user-data parameters") + func starterSignatureOmitsAsyncRoleParameters() throws { + let (context, klass) = makeContext() + let (plan, _) = planClass(klass, context: context) + let module = ModulePlan(module: "Gio", types: [.class(plan)], skips: [], coverage: CoverageStats()) + let files = renderModule(module) + let source = try #require(files["Widget.swift"]) + + // The starter takes no real parameters beyond the trailing async + // pair, so its emitted signature is empty parens. + #expect(source.contains("public func fooAsync() async throws")) + #expect(!source.contains("callback:")) + #expect(!source.contains("userData:")) + } +} diff --git a/Tests/GObjectGeneratorCoreTests/CallbackGenerationTests.swift b/Tests/GObjectGeneratorCoreTests/CallbackGenerationTests.swift index b2b44f1..6d88c8c 100644 --- a/Tests/GObjectGeneratorCoreTests/CallbackGenerationTests.swift +++ b/Tests/GObjectGeneratorCoreTests/CallbackGenerationTests.swift @@ -123,6 +123,43 @@ struct CallbackGenerationTests { #expect(mapping.swiftType.hasSuffix("-> String")) } + // MARK: - Declaring-namespace resolution (GIO async pattern, Step 1) + + @Test("A callback declared in namespace A whose parameter is a bare type in A, referenced from namespace B, maps successfully") + func callbackResolvesOwnParametersAgainstDeclaringNamespace() throws { + // Mirrors `Gio.AsyncReadyCallback`: Gio's own `` spells its + // `res` parameter as a bare `` (no + // namespace prefix), but Gdk references the callback type itself as + // `Gio.AsyncReadyCallback`. Resolving that bare `AsyncResult` against + // the CALLER's namespace ("B" here, "Gdk" for real) instead of the + // callback's OWN declaring namespace ("A" / "Gio") is exactly the bug + // Step 1 fixes. + let namespaceA = Repository(namespaces: [ + Namespace( + name: "A", version: "1.0", + enumerations: [ + Enumeration(name: "Status", cType: "AStatus", getTypeFunction: "a_status_get_type"), + ], + callbacks: [Callback( + name: "ReadyCallback", cType: "AReadyCallback", + parameters: [ + Parameter(name: "status", type: .typeRef("Status"), cType: "AStatus"), + ] + )] + ) + ]) + let namespaceB = Repository( + namespaces: [Namespace(name: "B", version: "1.0")], + includedPackages: [IncludeEntry(name: "A", version: "1.0")] + ) + let registry = TypeRegistry(repositories: ["A": namespaceA, "B": namespaceB]) + let ctx = MapContext(registry: registry, currentModule: "B", currentNamespace: "B", dependencyModules: ["A"]) + let mapping = try map(.typeRef("ReadyCallback", namespace: "A"), + nullable: false, transfer: .none, context: ctx) + #expect(mapping.category == .callback) + #expect(mapping.swiftType.contains("Status")) + } + // MARK: - Renderer infrastructure (constructed directly — D4.3 render-side proof) /// A `.callbackBox(scope: .call, …)` parameter that doubles as its own diff --git a/Tests/GObjectGeneratorCoreTests/TypeMapperTests.swift b/Tests/GObjectGeneratorCoreTests/TypeMapperTests.swift index 424c522..9ed6092 100644 --- a/Tests/GObjectGeneratorCoreTests/TypeMapperTests.swift +++ b/Tests/GObjectGeneratorCoreTests/TypeMapperTests.swift @@ -573,6 +573,37 @@ struct TypeMapperTests { } } + @Test("A gconstpointer-typed scalar buffer (no elementCType) maps to [UInt8]") + func arrayParamGconstpointerBuffer() throws { + // Mirrors g_bytes_new's `data` parameter: + // + // — the array's own c:type is the pointer TYPEDEF `gconstpointer` + // (no literal `*`), and the element has no c:type of its own. + let m = try mapArrayParameter( + element: .uint8, + info: ArrayInfo(lengthParameterIndex: 1, cType: "gconstpointer"), + transfer: .none, context: makeContext()) + #expect(m.swiftType == "[UInt8]") + #expect(m.marshalIn == .scalarArrayToC) + } + + @Test("A transfer=full gconstpointer-typed scalar buffer is rejected (the helper only lends a temporary copy)") + func arrayParamGconstpointerBufferTransferFullRejected() { + // Mirrors g_bytes_new_take's `data` parameter, transfer-ownership="full": + // the C callee frees the buffer, but `_withScalarArray` only lends a + // pointer into a temporary Swift copy for the call's duration. + do { + _ = try mapArrayParameter( + element: .uint8, + info: ArrayInfo(lengthParameterIndex: 1, cType: "gconstpointer"), + transfer: .full, context: makeContext()) + Issue.record("Expected transfer=full scalar buffer to be rejected") + } catch { + #expect(error.reason == .arrayBridgingUnimplemented) + #expect(error.detail.contains("transfer-ownership=full")) + } + } + @Test("A zero-terminated scalar buffer with no length param is rejected") func arrayParamScalarWithoutLengthRejected() { do { diff --git a/regression/tier6/Adw.json b/regression/tier6/Adw.json index ad7c921..ef69111 100644 --- a/regression/tier6/Adw.json +++ b/regression/tier6/Adw.json @@ -138,18 +138,6 @@ "reason" : "gtypeStruct", "symbol" : "Adw.BreakpointClass" }, - { - "cIdentifier" : "adw_breakpoint_condition_new_or", - "detail" : "Swift signature 'init(throws:false|ret:Void|(condition1:BreakpointCondition,condition2:BreakpointCondition))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Adw.BreakpointCondition.adw_breakpoint_condition_new_or" - }, - { - "cIdentifier" : "adw_breakpoint_condition_parse", - "detail" : "Swift signature 'parse(throws:false|ret:BreakpointCondition|(str:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Adw.BreakpointCondition.adw_breakpoint_condition_parse" - }, { "cIdentifier" : "AdwButtonContentClass", "detail" : "GObject class struct for 'ButtonContent'", @@ -662,7 +650,7 @@ }, { "cIdentifier" : "adw_preferences_group_bind_model", - "detail" : "parameter 'create_row_func': callback 'ListBoxCreateWidgetFunc' return unmappable: unresolved type 'Adw.Widget'", + "detail" : "callback param 'create_row_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Adw.bind_model" }, @@ -674,13 +662,13 @@ }, { "cIdentifier" : "adw_alert_dialog_choose", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Adw.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Adw.choose" }, { "cIdentifier" : "adw_message_dialog_choose", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Adw.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Adw.choose" }, @@ -813,7 +801,7 @@ ], "module" : "Adw", "stats" : { - "boundCallables" : 1248, + "boundCallables" : 1249, "boundCallbacks" : 2, "boundSignals" : 55, "boundTypes" : 126, diff --git a/regression/tier6/GLib.json b/regression/tier6/GLib.json index 59a0469..4ce4b75 100644 --- a/regression/tier6/GLib.json +++ b/regression/tier6/GLib.json @@ -24,15 +24,9 @@ "reason" : "plainRecord", "symbol" : "GLib.AsyncQueue" }, - { - "cIdentifier" : "g_bookmark_file_error_quark", - "detail" : "Swift signature 'errorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.BookmarkFile.g_bookmark_file_error_quark" - }, { "cIdentifier" : "g_bytes_new_take", - "detail" : "parameter 'data': scalar array C type 'gpointer' is not const (may be an output buffer)", + "detail" : "parameter 'data': scalar array with transfer-ownership=full", "reason" : "arrayBridgingUnimplemented", "symbol" : "GLib.Bytes.new_take" }, @@ -48,12 +42,6 @@ "reason" : "plainRecord", "symbol" : "GLib.Cache" }, - { - "cIdentifier" : "g_checksum_type_get_length", - "detail" : "Swift signature 'typeGetLength(throws:false|ret:Int|(checksumType:ChecksumType))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Checksum.g_checksum_type_get_length" - }, { "cIdentifier" : "GCompletion", "detail" : "no GType registration", @@ -78,30 +66,12 @@ "reason" : "unknownType", "symbol" : "GLib.Date" }, - { - "cIdentifier" : "g_date_time_new_from_unix_utc", - "detail" : "Swift signature 'init(throws:false|ret:Void|(t:Int))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.DateTime.g_date_time_new_from_unix_utc" - }, - { - "cIdentifier" : "g_date_time_new_from_unix_utc_usec", - "detail" : "Swift signature 'init(throws:false|ret:Void|(usecs:Int))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.DateTime.g_date_time_new_from_unix_utc_usec" - }, { "cIdentifier" : "g_date_time_new_now_utc", "detail" : "Swift signature 'init(throws:false|ret:Void|())' already emitted by an earlier symbol", "reason" : "nameCollision", "symbol" : "GLib.DateTime.g_date_time_new_now_utc" }, - { - "cIdentifier" : "g_date_time_new_utc", - "detail" : "Swift signature 'init(throws:false|ret:Void|(year:Int32,month:Int32,day:Int32,hour:Int32,minute:Int32,seconds:Double))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.DateTime.g_date_time_new_utc" - }, { "cIdentifier" : "g_date_time_new_from_timeval_local", "detail" : "parameter 'tv': 'GLib.TimeVal' has no GType registration or lifetime functions", @@ -120,12 +90,6 @@ "reason" : "plainRecord", "symbol" : "GLib.DebugKey" }, - { - "cIdentifier" : "g_dir_make_tmp", - "detail" : "Swift signature 'makeTmp(throws:true|ret:String|(tmpl:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Dir.g_dir_make_tmp" - }, { "cIdentifier" : "GError", "detail" : "record name 'Error' shadows Swift stdlib type", @@ -204,30 +168,12 @@ "reason" : "plainRecord", "symbol" : "GLib.IConv" }, - { - "cIdentifier" : "g_io_channel_error_from_errno", - "detail" : "Swift signature 'errorFromErrno(throws:false|ret:IOChannelError|(en:Int32))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.IOChannel.g_io_channel_error_from_errno" - }, - { - "cIdentifier" : "g_io_channel_error_quark", - "detail" : "Swift signature 'errorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.IOChannel.g_io_channel_error_quark" - }, { "cIdentifier" : "GIOFuncs", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.IOFuncs" }, - { - "cIdentifier" : "g_key_file_error_quark", - "detail" : "Swift signature 'errorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.KeyFile.g_key_file_error_quark" - }, { "cIdentifier" : "GList", "detail" : "no GType registration", @@ -246,24 +192,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "GLib.LogWriterFunc" }, - { - "cIdentifier" : "g_main_context_default", - "detail" : "Swift signature '`default`(throws:false|ret:MainContext|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.MainContext.g_main_context_default" - }, - { - "cIdentifier" : "g_main_context_get_thread_default", - "detail" : "Swift signature 'getThreadDefault(throws:false|ret:MainContext?|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.MainContext.g_main_context_get_thread_default" - }, - { - "cIdentifier" : "g_main_context_ref_thread_default", - "detail" : "Swift signature 'refThreadDefault(throws:false|ret:MainContext|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.MainContext.g_main_context_ref_thread_default" - }, { "cIdentifier" : "g_markup_parse_context_new", "detail" : "parameter 'parser': 'GLib.MarkupParser' has no GType registration or lifetime functions", @@ -384,36 +312,6 @@ "reason" : "plainRecord", "symbol" : "GLib.RecMutex" }, - { - "cIdentifier" : "g_regex_check_replacement", - "detail" : "Swift signature 'checkReplacement(throws:true|ret:Bool|(replacement:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Regex.g_regex_check_replacement" - }, - { - "cIdentifier" : "g_regex_error_quark", - "detail" : "Swift signature 'errorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Regex.g_regex_error_quark" - }, - { - "cIdentifier" : "g_regex_escape_nul", - "detail" : "Swift signature 'escapeNul(throws:false|ret:String|(string:String,length:Int32))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Regex.g_regex_escape_nul" - }, - { - "cIdentifier" : "g_regex_escape_string", - "detail" : "Swift signature 'escapeString(throws:false|ret:String|(string:String,length:Int32))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Regex.g_regex_escape_string" - }, - { - "cIdentifier" : "g_regex_match_simple", - "detail" : "Swift signature 'matchSimple(throws:false|ret:Bool|(pattern:String,string:String,compileOptions:RegexCompileFlags,matchOptions:RegexMatchFlags))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Regex.g_regex_match_simple" - }, { "cIdentifier" : "GRegexEvalCallback", "detail" : "callback 'RegexEvalCallback' has unmappable param/return: callback 'RegexEvalCallback' param 'result' unmappable: 'GLib.String' shadows reserved type 'String'", @@ -468,24 +366,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "GLib.SequenceIterCompareFunc" }, - { - "cIdentifier" : "g_source_remove", - "detail" : "Swift signature 'remove(throws:false|ret:Bool|(tag:UInt32))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Source.g_source_remove" - }, - { - "cIdentifier" : "g_source_remove_by_user_data", - "detail" : "Swift signature 'removeByUserData(throws:false|ret:Bool|(userData:UnsafeMutableRawPointer?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Source.g_source_remove_by_user_data" - }, - { - "cIdentifier" : "g_source_set_name_by_id", - "detail" : "Swift signature 'setNameById(throws:false|ret:Void|(tag:UInt32,name:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Source.g_source_set_name_by_id" - }, { "cIdentifier" : "g_source_new", "detail" : "parameter 'source_funcs': 'GLib.SourceFuncs' has no GType registration or lifetime functions", @@ -582,30 +462,6 @@ "reason" : "plainRecord", "symbol" : "GLib.TestSuite" }, - { - "cIdentifier" : "g_thread_error_quark", - "detail" : "Swift signature 'errorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Thread.g_thread_error_quark" - }, - { - "cIdentifier" : "g_thread_exit", - "detail" : "Swift signature 'exit(throws:false|ret:Void|(retval:UnsafeMutableRawPointer?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Thread.g_thread_exit" - }, - { - "cIdentifier" : "g_thread_self", - "detail" : "Swift signature '`self`(throws:false|ret:Thread|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Thread.g_thread_self" - }, - { - "cIdentifier" : "g_thread_yield", - "detail" : "Swift signature 'yield(throws:false|ret:Void|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Thread.g_thread_yield" - }, { "cIdentifier" : "g_thread_new", "detail" : "callback param 'func' deferred to Phase D4.3", @@ -642,12 +498,6 @@ "reason" : "plainRecord", "symbol" : "GLib.TimeVal" }, - { - "cIdentifier" : "g_time_zone_new_identifier", - "detail" : "Swift signature 'init(throws:false|ret:Void|(identifier:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.TimeZone.g_time_zone_new_identifier" - }, { "cIdentifier" : "g_time_zone_new_utc", "detail" : "Swift signature 'init(throws:false|ret:Void|())' already emitted by an earlier symbol", @@ -690,144 +540,12 @@ "reason" : "plainRecord", "symbol" : "GLib.Tuples" }, - { - "cIdentifier" : "g_uri_error_quark", - "detail" : "Swift signature 'errorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_error_quark" - }, - { - "cIdentifier" : "g_uri_escape_bytes", - "detail" : "Swift signature 'escapeBytes(throws:false|ret:String|(unescaped:[UInt8],reservedCharsAllowed:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_escape_bytes" - }, - { - "cIdentifier" : "g_uri_escape_string", - "detail" : "Swift signature 'escapeString(throws:false|ret:String|(unescaped:String,reservedCharsAllowed:String?,allowUtf8:Bool))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_escape_string" - }, - { - "cIdentifier" : "g_uri_is_valid", - "detail" : "Swift signature 'isValid(throws:true|ret:Bool|(uriString:String,flags:UriFlags))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_is_valid" - }, - { - "cIdentifier" : "g_uri_join", - "detail" : "Swift signature 'join(throws:false|ret:String|(flags:UriFlags,scheme:String?,userinfo:String?,host:String?,port:Int32,path:String,query:String?,fragment:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_join" - }, - { - "cIdentifier" : "g_uri_join_with_user", - "detail" : "Swift signature 'joinWithUser(throws:false|ret:String|(flags:UriFlags,scheme:String?,user:String?,password:String?,authParams:String?,host:String?,port:Int32,path:String,query:String?,fragment:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_join_with_user" - }, - { - "cIdentifier" : "g_uri_parse_scheme", - "detail" : "Swift signature 'parseScheme(throws:false|ret:String?|(uri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_parse_scheme" - }, - { - "cIdentifier" : "g_uri_peek_scheme", - "detail" : "Swift signature 'peekScheme(throws:false|ret:String?|(uri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_peek_scheme" - }, - { - "cIdentifier" : "g_uri_resolve_relative", - "detail" : "Swift signature 'resolveRelative(throws:true|ret:String|(baseUriString:String?,uriRef:String,flags:UriFlags))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_resolve_relative" - }, - { - "cIdentifier" : "g_uri_split", - "detail" : "Swift signature 'split(throws:true|ret:Bool|(uriRef:String,flags:UriFlags))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_split" - }, - { - "cIdentifier" : "g_uri_split_network", - "detail" : "Swift signature 'splitNetwork(throws:true|ret:Bool|(uriString:String,flags:UriFlags))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_split_network" - }, - { - "cIdentifier" : "g_uri_split_with_user", - "detail" : "Swift signature 'splitWithUser(throws:true|ret:Bool|(uriRef:String,flags:UriFlags))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_split_with_user" - }, - { - "cIdentifier" : "g_uri_unescape_bytes", - "detail" : "Swift signature 'unescapeBytes(throws:true|ret:Bytes|(escapedString:String,length:Int,illegalCharacters:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_unescape_bytes" - }, - { - "cIdentifier" : "g_uri_unescape_segment", - "detail" : "Swift signature 'unescapeSegment(throws:false|ret:String?|(escapedString:String?,escapedStringEnd:String?,illegalCharacters:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_unescape_segment" - }, - { - "cIdentifier" : "g_uri_unescape_string", - "detail" : "Swift signature 'unescapeString(throws:false|ret:String?|(escapedString:String,illegalCharacters:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Uri.g_uri_unescape_string" - }, { "cIdentifier" : "GUriParamsIter", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.UriParamsIter" }, - { - "cIdentifier" : "g_variant_is_object_path", - "detail" : "Swift signature 'isObjectPath(throws:false|ret:Bool|(string:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Variant.g_variant_is_object_path" - }, - { - "cIdentifier" : "g_variant_is_signature", - "detail" : "Swift signature 'isSignature(throws:false|ret:Bool|(string:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Variant.g_variant_is_signature" - }, - { - "cIdentifier" : "g_variant_new_int32", - "detail" : "Swift signature 'init(throws:false|ret:Void|(value:Int32))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Variant.g_variant_new_int32" - }, - { - "cIdentifier" : "g_variant_new_objv", - "detail" : "Swift signature 'init(throws:false|ret:Void|(strv:[String]))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Variant.g_variant_new_objv" - }, - { - "cIdentifier" : "g_variant_new_strv", - "detail" : "Swift signature 'init(throws:false|ret:Void|(strv:[String]))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Variant.g_variant_new_strv" - }, - { - "cIdentifier" : "g_variant_parse_error_quark", - "detail" : "Swift signature 'parseErrorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Variant.g_variant_parse_error_quark" - }, - { - "cIdentifier" : "g_variant_parser_get_error_quark", - "detail" : "Swift signature 'parserGetErrorQuark(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.Variant.g_variant_parser_get_error_quark" - }, { "cIdentifier" : "g_variant_new_array", "detail" : "parameter 'children': array element type 'Variant' is not an object or interface", @@ -858,36 +576,6 @@ "reason" : "plainRecord", "symbol" : "GLib.VariantIter" }, - { - "cIdentifier" : "g_variant_type_checked_", - "detail" : "Swift signature 'checked(throws:false|ret:VariantType|(typeString:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.VariantType.g_variant_type_checked_" - }, - { - "cIdentifier" : "g_variant_type_new_maybe", - "detail" : "Swift signature 'init(throws:false|ret:Void|(element:VariantType))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.VariantType.g_variant_type_new_maybe" - }, - { - "cIdentifier" : "g_variant_type_string_get_depth_", - "detail" : "Swift signature 'stringGetDepth(throws:false|ret:UInt|(typeString:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.VariantType.g_variant_type_string_get_depth_" - }, - { - "cIdentifier" : "g_variant_type_string_is_valid", - "detail" : "Swift signature 'stringIsValid(throws:false|ret:Bool|(typeString:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.VariantType.g_variant_type_string_is_valid" - }, - { - "cIdentifier" : "g_variant_type_string_scan", - "detail" : "Swift signature 'stringScan(throws:false|ret:Bool|(string:String,limit:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GLib.VariantType.g_variant_type_string_scan" - }, { "cIdentifier" : "g_variant_type_new_tuple", "detail" : "parameter 'items': array element type 'VariantType' is not an object or interface", @@ -1256,7 +944,7 @@ }, { "cIdentifier" : "g_byte_array_new_take", - "detail" : "parameter 'data': scalar array C type 'guint8*' is not const (may be an output buffer)", + "detail" : "parameter 'data': scalar array with transfer-ownership=full", "reason" : "arrayBridgingUnimplemented", "symbol" : "GLib.byte_array_new_take" }, @@ -2420,7 +2108,7 @@ }, { "cIdentifier" : "g_byte_array_new_take", - "detail" : "parameter 'data': scalar array C type 'guint8*' is not const (may be an output buffer)", + "detail" : "parameter 'data': scalar array with transfer-ownership=full", "reason" : "arrayBridgingUnimplemented", "symbol" : "GLib.new_take" }, @@ -3807,7 +3495,7 @@ ], "module" : "GLib", "stats" : { - "boundCallables" : 808, + "boundCallables" : 816, "boundCallbacks" : 61, "boundSignals" : 0, "boundTypes" : 287, diff --git a/regression/tier6/GObject.json b/regression/tier6/GObject.json index 486fe94..dcfe35b 100644 --- a/regression/tier6/GObject.json +++ b/regression/tier6/GObject.json @@ -276,18 +276,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "GObject.VaClosureMarshal" }, - { - "cIdentifier" : "g_value_type_compatible", - "detail" : "Swift signature 'typeCompatible(throws:false|ret:Bool|(srcType:UInt,destType:UInt))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GObject.Value.g_value_type_compatible" - }, - { - "cIdentifier" : "g_value_type_transformable", - "detail" : "Swift signature 'typeTransformable(throws:false|ret:Bool|(srcType:UInt,destType:UInt))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "GObject.Value.g_value_type_transformable" - }, { "cIdentifier" : "GWeakRef", "detail" : "no GType registration", diff --git a/regression/tier6/Gdk.json b/regression/tier6/Gdk.json index e56e42e..b996f3e 100644 --- a/regression/tier6/Gdk.json +++ b/regression/tier6/Gdk.json @@ -6,48 +6,6 @@ "reason" : "gtypeStruct", "symbol" : "Gdk.CicpParamsClass" }, - { - "cIdentifier" : "gdk_color_state_get_oklab", - "detail" : "Swift signature 'getOklab(throws:false|ret:ColorState|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gdk.ColorState.gdk_color_state_get_oklab" - }, - { - "cIdentifier" : "gdk_color_state_get_oklch", - "detail" : "Swift signature 'getOklch(throws:false|ret:ColorState|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gdk.ColorState.gdk_color_state_get_oklch" - }, - { - "cIdentifier" : "gdk_color_state_get_rec2100_linear", - "detail" : "Swift signature 'getRec2100Linear(throws:false|ret:ColorState|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gdk.ColorState.gdk_color_state_get_rec2100_linear" - }, - { - "cIdentifier" : "gdk_color_state_get_rec2100_pq", - "detail" : "Swift signature 'getRec2100Pq(throws:false|ret:ColorState|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gdk.ColorState.gdk_color_state_get_rec2100_pq" - }, - { - "cIdentifier" : "gdk_color_state_get_srgb", - "detail" : "Swift signature 'getSrgb(throws:false|ret:ColorState|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gdk.ColorState.gdk_color_state_get_srgb" - }, - { - "cIdentifier" : "gdk_color_state_get_srgb_linear", - "detail" : "Swift signature 'getSrgbLinear(throws:false|ret:ColorState|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gdk.ColorState.gdk_color_state_get_srgb_linear" - }, - { - "cIdentifier" : "gdk_content_formats_parse", - "detail" : "Swift signature 'parse(throws:false|ret:ContentFormats?|(string:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gdk.ContentFormats.gdk_content_formats_parse" - }, { "cIdentifier" : "gdk_content_provider_new_union", "detail" : "parameter 'providers': object array with transfer-ownership=full", @@ -2305,7 +2263,7 @@ }, { "cIdentifier" : "gdk_content_deserialize_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gdk.content_deserialize_async" }, @@ -2327,12 +2285,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gdk.content_register_serializer" }, - { - "cIdentifier" : "gdk_content_serialize_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.content_serialize_async" - }, { "cIdentifier" : "gdk_surface_create_similar_surface", "detail" : "parameter 'content': type 'cairo.Content' lives in unavailable namespace 'cairo'", @@ -2525,42 +2477,6 @@ "reason" : "unknownType", "symbol" : "Gdk.print" }, - { - "cIdentifier" : "gdk_clipboard_read_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.read_async" - }, - { - "cIdentifier" : "gdk_drop_read_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.read_async" - }, - { - "cIdentifier" : "gdk_clipboard_read_text_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.read_text_async" - }, - { - "cIdentifier" : "gdk_clipboard_read_texture_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.read_texture_async" - }, - { - "cIdentifier" : "gdk_clipboard_read_value_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.read_value_async" - }, - { - "cIdentifier" : "gdk_drop_read_value_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.read_value_async" - }, { "cIdentifier" : "gdk_content_deserializer_return_error", "detail" : "parameter 'error': 'GLib.Error' shadows reserved type 'Error'", @@ -2621,12 +2537,6 @@ "reason" : "foreignNamespace", "symbol" : "Gdk.set_update_region" }, - { - "cIdentifier" : "gdk_clipboard_store_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.store_async" - }, { "cIdentifier" : "gdk_texture_error_quark", "detail" : "moved-to target type 'TextureError' was not planned", @@ -2650,17 +2560,11 @@ "detail" : "moved-to target type 'VulkanError' was not planned", "reason" : "movedToTargetMissing", "symbol" : "Gdk.vulkan_error_quark" - }, - { - "cIdentifier" : "gdk_content_provider_write_mime_type_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gdk.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Gdk.write_mime_type_async" } ], "module" : "Gdk", "stats" : { - "boundCallables" : 440, + "boundCallables" : 449, "boundCallbacks" : 3, "boundSignals" : 34, "boundTypes" : 2225, diff --git a/regression/tier6/GdkPixbuf.json b/regression/tier6/GdkPixbuf.json index 31e65ca..fb38d89 100644 --- a/regression/tier6/GdkPixbuf.json +++ b/regression/tier6/GdkPixbuf.json @@ -102,12 +102,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "GdkPixbuf.get_extensions" }, - { - "cIdentifier" : "gdk_pixbuf_get_file_info_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'GdkPixbuf.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "GdkPixbuf.get_file_info_async" - }, { "cIdentifier" : "gdk_pixbuf_get_formats", "detail" : "slist container with 1 element(s) not yet bridged", @@ -140,19 +134,19 @@ }, { "cIdentifier" : "gdk_pixbuf_new_from_stream_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'GdkPixbuf.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GdkPixbuf.new_from_stream_async" }, { "cIdentifier" : "gdk_pixbuf_animation_new_from_stream_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'GdkPixbuf.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GdkPixbuf.new_from_stream_async" }, { "cIdentifier" : "gdk_pixbuf_new_from_stream_at_scale_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'GdkPixbuf.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GdkPixbuf.new_from_stream_at_scale_async" }, @@ -182,14 +176,14 @@ }, { "cIdentifier" : "gdk_pixbuf_save_to_streamv_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'GdkPixbuf.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GdkPixbuf.save_to_streamv_async" } ], "module" : "GdkPixbuf", "stats" : { - "boundCallables" : 80, + "boundCallables" : 81, "boundCallbacks" : 15, "boundSignals" : 4, "boundTypes" : 27, diff --git a/regression/tier6/Gio.json b/regression/tier6/Gio.json index 1709d0b..3fb5abb 100644 --- a/regression/tier6/Gio.json +++ b/regression/tier6/Gio.json @@ -172,12 +172,6 @@ "reason" : "signalUnmappableParam", "symbol" : "Gio.DBusConnection.closed" }, - { - "cIdentifier" : "g_dbus_connection_new_for_address_finish", - "detail" : "Swift signature 'init(throws:true|ret:Void|(res:AsyncResult))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gio.DBusConnection.g_dbus_connection_new_for_address_finish" - }, { "cIdentifier" : "GDBusErrorEntry", "detail" : "no GType registration", @@ -232,12 +226,6 @@ "reason" : "gtypeStruct", "symbol" : "Gio.DBusObjectIface" }, - { - "cIdentifier" : "g_dbus_object_manager_client_new_for_bus_finish", - "detail" : "Swift signature 'init(throws:true|ret:Void|(res:AsyncResult))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gio.DBusObjectManagerClient.g_dbus_object_manager_client_new_for_bus_finish" - }, { "detail" : "param 'invalidated_properties': C array bridging not yet implemented", "reason" : "signalUnmappableParam", @@ -314,12 +302,6 @@ "reason" : "signalUnmappableParam", "symbol" : "Gio.DBusProxy.g-properties-changed" }, - { - "cIdentifier" : "g_dbus_proxy_new_for_bus_finish", - "detail" : "Swift signature 'init(throws:true|ret:Void|(res:AsyncResult))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gio.DBusProxy.g_dbus_proxy_new_for_bus_finish" - }, { "cIdentifier" : "GDBusProxyClass", "detail" : "GObject class struct for 'DBusProxy'", @@ -656,12 +638,6 @@ "reason" : "gtypeStruct", "symbol" : "Gio.IconIface" }, - { - "cIdentifier" : "g_inet_address_new_loopback", - "detail" : "Swift signature 'init(throws:false|ret:Void|(family:SocketFamily))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gio.InetAddress.g_inet_address_new_loopback" - }, { "cIdentifier" : "g_inet_address_new_from_bytes", "detail" : "parameter 'bytes': C array has no length annotation", @@ -760,7 +736,7 @@ }, { "cIdentifier" : "g_memory_input_stream_new_from_data", - "detail" : "parameter 'data': scalar array C type 'void*' is not const (may be an output buffer)", + "detail" : "parameter 'data': scalar array with transfer-ownership=full", "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.MemoryInputStream.new_from_data" }, @@ -1026,12 +1002,6 @@ "reason" : "plainRecord", "symbol" : "Gio.ResolverPrivate" }, - { - "cIdentifier" : "g_resource_load", - "detail" : "Swift signature 'load(throws:true|ret:Resource|(filename:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gio.Resource.g_resource_load" - }, { "cIdentifier" : "GSeekableIface", "detail" : "GObject class struct for 'Seekable'", @@ -1067,12 +1037,6 @@ "reason" : "plainRecord", "symbol" : "Gio.SettingsPrivate" }, - { - "cIdentifier" : "g_settings_schema_source_get_default", - "detail" : "Swift signature 'getDefault(throws:false|ret:SettingsSchemaSource?|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gio.SettingsSchemaSource.g_settings_schema_source_get_default" - }, { "cIdentifier" : "GSimpleActionGroupClass", "detail" : "GObject class struct for 'SimpleActionGroup'", @@ -1277,12 +1241,6 @@ "reason" : "plainRecord", "symbol" : "Gio.TcpWrapperConnectionPrivate" }, - { - "cIdentifier" : "g_themed_icon_new_with_default_fallbacks", - "detail" : "Swift signature 'init(throws:false|ret:Void|(iconname:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gio.ThemedIcon.g_themed_icon_new_with_default_fallbacks" - }, { "cIdentifier" : "names", "detail" : "C array bridging not yet implemented", @@ -1565,12 +1523,6 @@ "reason" : "outParameter", "symbol" : "Gio.accept_socket_finish" }, - { - "cIdentifier" : "g_permission_acquire_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.acquire_async" - }, { "cIdentifier" : "g_action_name_is_valid", "detail" : "moved-to target type 'Action' was not planned", @@ -1603,7 +1555,7 @@ }, { "cIdentifier" : "g_memory_input_stream_add_data", - "detail" : "parameter 'data': scalar array C type 'void*' is not const (may be an output buffer)", + "detail" : "parameter 'data': scalar array with transfer-ownership=full", "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.add_data" }, @@ -1715,18 +1667,6 @@ "reason" : "movedToTargetMissing", "symbol" : "Gio.app_info_reset_type_associations" }, - { - "cIdentifier" : "g_file_append_to_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.append_to_async" - }, - { - "cIdentifier" : "g_tls_interaction_ask_password_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.ask_password_async" - }, { "cIdentifier" : "g_async_initable_newv_async", "detail" : "moved-to target type 'AsyncInitable' was not planned", @@ -1817,12 +1757,6 @@ "reason" : "outParameter", "symbol" : "Gio.call_with_unix_fd_list_sync" }, - { - "cIdentifier" : "g_network_monitor_can_reach_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.can_reach_async" - }, { "cIdentifier" : "g_settings_backend_changed", "detail" : "C symbol 'g_settings_backend_changed' is not visible through the public umbrella header", @@ -1841,36 +1775,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.close" }, - { - "cIdentifier" : "g_file_enumerator_close_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.close_async" - }, - { - "cIdentifier" : "g_io_stream_close_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.close_async" - }, - { - "cIdentifier" : "g_input_stream_close_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.close_async" - }, - { - "cIdentifier" : "g_output_stream_close_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.close_async" - }, - { - "cIdentifier" : "g_dtls_connection_close_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.close_async" - }, { "cIdentifier" : "g_subprocess_communicate", "detail" : "object/boxed out-param 'stdout_buf' deferred", @@ -1889,54 +1793,12 @@ "reason" : "outParameter", "symbol" : "Gio.communicate_finish" }, - { - "cIdentifier" : "g_subprocess_communicate_utf8_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.communicate_utf8_async" - }, { "cIdentifier" : "g_cancellable_connect", "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gio.connect" }, - { - "cIdentifier" : "g_socket_client_connect_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.connect_async" - }, - { - "cIdentifier" : "g_socket_connection_connect_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.connect_async" - }, - { - "cIdentifier" : "g_proxy_connect_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.connect_async" - }, - { - "cIdentifier" : "g_socket_client_connect_to_host_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.connect_to_host_async" - }, - { - "cIdentifier" : "g_socket_client_connect_to_service_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.connect_to_service_async" - }, - { - "cIdentifier" : "g_socket_client_connect_to_uri_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.connect_to_uri_async" - }, { "cIdentifier" : "g_content_type_get_mime_dirs", "detail" : "C array bridging not yet implemented", @@ -1967,18 +1829,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.copy" }, - { - "cIdentifier" : "g_file_create_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.create_async" - }, - { - "cIdentifier" : "g_file_create_readwrite_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.create_readwrite_async" - }, { "cIdentifier" : "g_dbus_address_get_stream", "detail" : "callback param 'callback' deferred to Phase D4.3", @@ -2063,12 +1913,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.dbus_unescape_object_path" }, - { - "cIdentifier" : "g_file_delete_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.delete_async" - }, { "cIdentifier" : "g_socket_control_message_deserialize", "detail" : "parameter 'data': scalar array C type 'gpointer' is not const (may be an output buffer)", @@ -2141,12 +1985,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.enumerate_children" }, - { - "cIdentifier" : "g_file_enumerate_children_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.enumerate_children_async" - }, { "cIdentifier" : "g_drive_enumerate_identifiers", "detail" : "C array bridging not yet implemented", @@ -2225,18 +2063,6 @@ "reason" : "movedToTargetMissing", "symbol" : "Gio.file_parse_name" }, - { - "cIdentifier" : "g_buffered_input_stream_fill_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.fill_async" - }, - { - "cIdentifier" : "g_file_find_enclosing_mount_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.find_enclosing_mount_async" - }, { "cIdentifier" : "g_list_store_find_with_equal_func", "detail" : "callback param 'equal_func' deferred to Phase D4.3", @@ -2261,12 +2087,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.flush" }, - { - "cIdentifier" : "g_output_stream_flush_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.flush_async" - }, { "cIdentifier" : "g_dbus_interface_info_generate_xml", "detail" : "parameter 'string_builder': 'GLib.String' shadows reserved type 'String'", @@ -2513,18 +2333,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.guess_content_type_sync" }, - { - "cIdentifier" : "g_tls_connection_handshake_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.handshake_async" - }, - { - "cIdentifier" : "g_dtls_connection_handshake_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.handshake_async" - }, { "cIdentifier" : "g_icon_deserialize", "detail" : "moved-to target type 'Icon' was not planned", @@ -2537,12 +2345,6 @@ "reason" : "movedToTargetMissing", "symbol" : "Gio.icon_new_for_string" }, - { - "cIdentifier" : "g_async_initable_init_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.init_async" - }, { "cIdentifier" : "g_initable_newv", "detail" : "moved-to target type 'Initable' was not planned", @@ -2693,18 +2495,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.list_schemas" }, - { - "cIdentifier" : "g_loadable_icon_load_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.load_async" - }, - { - "cIdentifier" : "g_file_load_bytes_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.load_bytes_async" - }, { "cIdentifier" : "g_file_load_contents", "detail" : "out-param 'contents': C array bridging not yet implemented", @@ -2753,12 +2543,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.lookup_async" }, - { - "cIdentifier" : "g_resolver_lookup_by_address_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.lookup_by_address_async" - }, { "cIdentifier" : "g_resolver_lookup_by_name", "detail" : "list container with 1 element(s) not yet bridged", @@ -2795,18 +2579,6 @@ "reason" : "containerType", "symbol" : "Gio.lookup_by_name_with_flags_finish" }, - { - "cIdentifier" : "g_tls_database_lookup_certificate_for_handle_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.lookup_certificate_for_handle_async" - }, - { - "cIdentifier" : "g_tls_database_lookup_certificate_issuer_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.lookup_certificate_issuer_async" - }, { "cIdentifier" : "g_tls_database_lookup_certificates_issued_by", "detail" : "parameter 'issuer_raw_dn': byteArray container with 1 element(s) not yet bridged", @@ -2867,18 +2639,6 @@ "reason" : "containerType", "symbol" : "Gio.lookup_service_finish" }, - { - "cIdentifier" : "g_file_make_directory_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.make_directory_async" - }, - { - "cIdentifier" : "g_file_make_symbolic_link_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.make_symbolic_link_async" - }, { "cIdentifier" : "g_file_measure_disk_usage", "detail" : "callback param 'progress_callback' deferred to Phase D4.3", @@ -2969,12 +2729,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.new_for_bus" }, - { - "cIdentifier" : "g_socket_address_enumerator_next_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.next_async" - }, { "cIdentifier" : "g_file_enumerator_next_files_async", "detail" : "callback param 'callback' deferred to Phase D4.3", @@ -2993,12 +2747,6 @@ "reason" : "unknownType", "symbol" : "Gio.null_settings_backend_new" }, - { - "cIdentifier" : "g_file_open_readwrite_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.open_readwrite_async" - }, { "cIdentifier" : "g_settings_backend_path_changed", "detail" : "C symbol 'g_settings_backend_path_changed' is not visible through the public umbrella header", @@ -3095,42 +2843,6 @@ "reason" : "outParameter", "symbol" : "Gio.query_action" }, - { - "cIdentifier" : "g_file_query_default_handler_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.query_default_handler_async" - }, - { - "cIdentifier" : "g_file_query_filesystem_info_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.query_filesystem_info_async" - }, - { - "cIdentifier" : "g_file_io_stream_query_info_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.query_info_async" - }, - { - "cIdentifier" : "g_file_input_stream_query_info_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.query_info_async" - }, - { - "cIdentifier" : "g_file_output_stream_query_info_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.query_info_async" - }, - { - "cIdentifier" : "g_file_query_info_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.query_info_async" - }, { "cIdentifier" : "g_input_stream_read", "detail" : "caller-allocates out-param 'buffer' (no buffer size in GIR)", @@ -3155,18 +2867,6 @@ "reason" : "outParameter", "symbol" : "Gio.read_async" }, - { - "cIdentifier" : "g_file_read_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.read_async" - }, - { - "cIdentifier" : "g_input_stream_read_bytes_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.read_bytes_async" - }, { "cIdentifier" : "g_data_input_stream_read_line", "detail" : "C array bridging not yet implemented", @@ -3191,18 +2891,6 @@ "reason" : "outParameter", "symbol" : "Gio.read_nonblocking" }, - { - "cIdentifier" : "g_data_input_stream_read_until_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.read_until_async" - }, - { - "cIdentifier" : "g_data_input_stream_read_upto_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.read_upto_async" - }, { "cIdentifier" : "g_socket_receive", "detail" : "caller-allocates out-param 'buffer' (no buffer size in GIR)", @@ -3215,12 +2903,6 @@ "reason" : "outParameter", "symbol" : "Gio.receive_bytes_from" }, - { - "cIdentifier" : "g_unix_connection_receive_credentials_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.receive_credentials_async" - }, { "cIdentifier" : "g_socket_receive_from", "detail" : "object/boxed out-param 'address' deferred", @@ -3263,12 +2945,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.register_uri_scheme" }, - { - "cIdentifier" : "g_permission_release_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.release_async" - }, { "cIdentifier" : "g_mount_remount", "detail" : "callback param 'callback' deferred to Phase D4.3", @@ -3281,42 +2957,18 @@ "reason" : "plainRecord", "symbol" : "Gio.remove_action_entries" }, - { - "cIdentifier" : "g_file_replace_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.replace_async" - }, - { - "cIdentifier" : "g_file_replace_contents_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.replace_contents_async" - }, { "cIdentifier" : "g_file_replace_contents_bytes_async", "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gio.replace_contents_bytes_async" }, - { - "cIdentifier" : "g_file_replace_readwrite_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.replace_readwrite_async" - }, { "cIdentifier" : "g_task_report_error", "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gio.report_error" }, - { - "cIdentifier" : "g_tls_interaction_request_certificate_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.request_certificate_async" - }, { "cIdentifier" : "g_resolver_error_quark", "detail" : "moved-to target type 'ResolverError' was not planned", @@ -3365,12 +3017,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.run_in_thread_sync" }, - { - "cIdentifier" : "g_unix_connection_send_credentials_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.send_credentials_async" - }, { "cIdentifier" : "g_socket_send_message", "detail" : "parameter 'vectors': 'Gio.OutputVector' has no GType registration or lifetime functions", @@ -3413,12 +3059,6 @@ "reason" : "outParameter", "symbol" : "Gio.set_attributes_finish" }, - { - "cIdentifier" : "g_file_set_display_name_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.set_display_name_async" - }, { "cIdentifier" : "g_simple_async_result_set_from_error", "detail" : "parameter 'error': 'GLib.Error' shadows reserved type 'Error'", @@ -3449,12 +3089,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.set_value_full" }, - { - "cIdentifier" : "g_dtls_connection_shutdown_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.shutdown_async" - }, { "cIdentifier" : "g_dbus_connection_signal_subscribe", "detail" : "callback param 'callback' deferred to Phase D4.3", @@ -3479,30 +3113,12 @@ "reason" : "notIntrospectable", "symbol" : "Gio.simple_async_report_take_gerror_in_idle" }, - { - "cIdentifier" : "g_input_stream_skip_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.skip_async" - }, { "cIdentifier" : "g_list_store_sort", "detail" : "callback param 'compare_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gio.sort" }, - { - "cIdentifier" : "g_io_stream_splice_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.splice_async" - }, - { - "cIdentifier" : "g_output_stream_splice_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.splice_async" - }, { "cIdentifier" : "g_srv_target_list_sort", "detail" : "parameter 'targets': list container with 1 element(s) not yet bridged", @@ -3581,12 +3197,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.to_blob" }, - { - "cIdentifier" : "g_file_trash_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.trash_async" - }, { "cIdentifier" : "g_mount_unmount", "detail" : "callback param 'callback' deferred to Phase D4.3", @@ -3611,24 +3221,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gio.unmount_with_operation" }, - { - "cIdentifier" : "g_tls_database_verify_chain_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.verify_chain_async" - }, - { - "cIdentifier" : "g_subprocess_wait_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.wait_async" - }, - { - "cIdentifier" : "g_subprocess_wait_check_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.wait_check_async" - }, { "cIdentifier" : "g_settings_backend_writable_changed", "detail" : "C symbol 'g_settings_backend_writable_changed' is not visible through the public umbrella header", @@ -3659,12 +3251,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gio.write_async" }, - { - "cIdentifier" : "g_output_stream_write_bytes_async", - "detail" : "callback param 'callback' deferred to Phase D4.3", - "reason" : "callbackWithoutUserData", - "symbol" : "Gio.write_bytes_async" - }, { "cIdentifier" : "g_pollable_output_stream_write_nonblocking", "detail" : "parameter 'buffer': scalar array C type 'void*' is not const (may be an output buffer)", @@ -3704,7 +3290,7 @@ ], "module" : "Gio", "stats" : { - "boundCallables" : 1036, + "boundCallables" : 1077, "boundCallbacks" : 30, "boundSignals" : 72, "boundTypes" : 393, diff --git a/regression/tier6/Graphene.json b/regression/tier6/Graphene.json index 45cbe24..052da00 100644 --- a/regression/tier6/Graphene.json +++ b/regression/tier6/Graphene.json @@ -1,59 +1,5 @@ { "entries" : [ - { - "cIdentifier" : "graphene_box_empty", - "detail" : "Swift signature 'empty(throws:false|ret:Box|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Box.graphene_box_empty" - }, - { - "cIdentifier" : "graphene_box_infinite", - "detail" : "Swift signature 'infinite(throws:false|ret:Box|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Box.graphene_box_infinite" - }, - { - "cIdentifier" : "graphene_box_minus_one", - "detail" : "Swift signature 'minusOne(throws:false|ret:Box|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Box.graphene_box_minus_one" - }, - { - "cIdentifier" : "graphene_box_one", - "detail" : "Swift signature 'one(throws:false|ret:Box|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Box.graphene_box_one" - }, - { - "cIdentifier" : "graphene_box_one_minus_one", - "detail" : "Swift signature 'oneMinusOne(throws:false|ret:Box|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Box.graphene_box_one_minus_one" - }, - { - "cIdentifier" : "graphene_box_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Box|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Box.graphene_box_zero" - }, - { - "cIdentifier" : "graphene_point_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Point|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Point.graphene_point_zero" - }, - { - "cIdentifier" : "graphene_point3d_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Point3D|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Point3D.graphene_point3d_zero" - }, - { - "cIdentifier" : "graphene_rect_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Rect|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Rect.graphene_rect_zero" - }, { "cIdentifier" : "graphene_simd4f_t", "detail" : "no GType registration", @@ -66,102 +12,6 @@ "reason" : "plainRecord", "symbol" : "Graphene.Simd4X4F" }, - { - "cIdentifier" : "graphene_size_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Size|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Size.graphene_size_zero" - }, - { - "cIdentifier" : "graphene_vec2_one", - "detail" : "Swift signature 'one(throws:false|ret:Vec2|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec2.graphene_vec2_one" - }, - { - "cIdentifier" : "graphene_vec2_x_axis", - "detail" : "Swift signature 'xAxis(throws:false|ret:Vec2|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec2.graphene_vec2_x_axis" - }, - { - "cIdentifier" : "graphene_vec2_y_axis", - "detail" : "Swift signature 'yAxis(throws:false|ret:Vec2|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec2.graphene_vec2_y_axis" - }, - { - "cIdentifier" : "graphene_vec2_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Vec2|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec2.graphene_vec2_zero" - }, - { - "cIdentifier" : "graphene_vec3_one", - "detail" : "Swift signature 'one(throws:false|ret:Vec3|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec3.graphene_vec3_one" - }, - { - "cIdentifier" : "graphene_vec3_x_axis", - "detail" : "Swift signature 'xAxis(throws:false|ret:Vec3|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec3.graphene_vec3_x_axis" - }, - { - "cIdentifier" : "graphene_vec3_y_axis", - "detail" : "Swift signature 'yAxis(throws:false|ret:Vec3|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec3.graphene_vec3_y_axis" - }, - { - "cIdentifier" : "graphene_vec3_z_axis", - "detail" : "Swift signature 'zAxis(throws:false|ret:Vec3|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec3.graphene_vec3_z_axis" - }, - { - "cIdentifier" : "graphene_vec3_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Vec3|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec3.graphene_vec3_zero" - }, - { - "cIdentifier" : "graphene_vec4_one", - "detail" : "Swift signature 'one(throws:false|ret:Vec4|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec4.graphene_vec4_one" - }, - { - "cIdentifier" : "graphene_vec4_w_axis", - "detail" : "Swift signature 'wAxis(throws:false|ret:Vec4|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec4.graphene_vec4_w_axis" - }, - { - "cIdentifier" : "graphene_vec4_x_axis", - "detail" : "Swift signature 'xAxis(throws:false|ret:Vec4|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec4.graphene_vec4_x_axis" - }, - { - "cIdentifier" : "graphene_vec4_y_axis", - "detail" : "Swift signature 'yAxis(throws:false|ret:Vec4|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec4.graphene_vec4_y_axis" - }, - { - "cIdentifier" : "graphene_vec4_z_axis", - "detail" : "Swift signature 'zAxis(throws:false|ret:Vec4|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec4.graphene_vec4_z_axis" - }, - { - "cIdentifier" : "graphene_vec4_zero", - "detail" : "Swift signature 'zero(throws:false|ret:Vec4|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Graphene.Vec4.graphene_vec4_zero" - }, { "cIdentifier" : "graphene_quaternion_add", "detail" : "caller-allocates out-param 'res' (no buffer size in GIR)", diff --git a/regression/tier6/Gsk.json b/regression/tier6/Gsk.json index 89b015f..bff52c6 100644 --- a/regression/tier6/Gsk.json +++ b/regression/tier6/Gsk.json @@ -30,12 +30,6 @@ "reason" : "plainRecord", "symbol" : "Gsk.ColorStop" }, - { - "cIdentifier" : "gsk_component_transfer_equal", - "detail" : "Swift signature 'equal(throws:false|ret:Bool|(`self`:UnsafeMutableRawPointer?,other:UnsafeMutableRawPointer?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gsk.ComponentTransfer.gsk_component_transfer_equal" - }, { "cIdentifier" : "gsk_component_transfer_new_discrete", "detail" : "parameter 'values': scalar array C type 'float*' is not const (may be an output buffer)", @@ -102,12 +96,6 @@ "reason" : "plainRecord", "symbol" : "Gsk.ParseLocation" }, - { - "cIdentifier" : "gsk_path_parse", - "detail" : "Swift signature 'parse(throws:false|ret:Path?|(string:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gsk.Path.gsk_path_parse" - }, { "cIdentifier" : "GskPathForeachFunc", "detail" : "callback 'PathForeachFunc' has unmappable param/return: callback 'PathForeachFunc' param 'pts' unmappable: C array bridging not yet implemented", @@ -180,12 +168,6 @@ "reason" : "plainRecord", "symbol" : "Gsk.ShadowNode.new" }, - { - "cIdentifier" : "gsk_stroke_equal", - "detail" : "Swift signature 'equal(throws:false|ret:Bool|(stroke1:UnsafeMutableRawPointer?,stroke2:UnsafeMutableRawPointer?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gsk.Stroke.gsk_stroke_equal" - }, { "cIdentifier" : "GskVulkanRendererClass", "detail" : "GObject class struct for 'VulkanRenderer'", diff --git a/regression/tier6/Gst.json b/regression/tier6/Gst.json index 9fa85fb..4889709 100644 --- a/regression/tier6/Gst.json +++ b/regression/tier6/Gst.json @@ -24,15 +24,9 @@ "reason" : "plainRecord", "symbol" : "Gst.BinPrivate" }, - { - "cIdentifier" : "gst_buffer_get_max_memory", - "detail" : "Swift signature 'getMaxMemory(throws:false|ret:UInt32|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Buffer.gst_buffer_get_max_memory" - }, { "cIdentifier" : "gst_buffer_new_wrapped", - "detail" : "parameter 'data': scalar array C type 'gpointer' is not const (may be an output buffer)", + "detail" : "parameter 'data': scalar array with transfer-ownership=full", "reason" : "arrayBridgingUnimplemented", "symbol" : "Gst.Buffer.new_wrapped" }, @@ -102,30 +96,12 @@ "reason" : "nameCollision", "symbol" : "Gst.Caps.gst_caps_new_empty" }, - { - "cIdentifier" : "gst_caps_new_static_str_empty_simple", - "detail" : "Swift signature 'init(throws:false|ret:Void|(mediaType:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Caps.gst_caps_new_static_str_empty_simple" - }, - { - "cIdentifier" : "gst_caps_features_from_string", - "detail" : "Swift signature 'fromString(throws:false|ret:CapsFeatures?|(features:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.CapsFeatures.gst_caps_features_from_string" - }, { "cIdentifier" : "gst_caps_features_new_empty", "detail" : "Swift signature 'init(throws:false|ret:Void|())' already emitted by an earlier symbol", "reason" : "nameCollision", "symbol" : "Gst.CapsFeatures.gst_caps_features_new_empty" }, - { - "cIdentifier" : "gst_caps_features_new_single_static_str", - "detail" : "Swift signature 'init(throws:false|ret:Void|(feature:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.CapsFeatures.gst_caps_features_new_single_static_str" - }, { "cIdentifier" : "GstChildProxyInterface", "detail" : "GObject class struct for 'ChildProxy'", @@ -186,18 +162,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gst.CustomMetaTransformFunction" }, - { - "cIdentifier" : "gst_date_time_new_from_unix_epoch_utc", - "detail" : "Swift signature 'init(throws:false|ret:Void|(secs:Int))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.DateTime.gst_date_time_new_from_unix_epoch_utc" - }, - { - "cIdentifier" : "gst_date_time_new_from_unix_epoch_utc_usecs", - "detail" : "Swift signature 'init(throws:false|ret:Void|(usecs:Int))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.DateTime.gst_date_time_new_from_unix_epoch_utc_usecs" - }, { "cIdentifier" : "gst_date_time_new_now_utc", "detail" : "Swift signature 'init(throws:false|ret:Void|())' already emitted by an earlier symbol", @@ -378,72 +342,6 @@ "reason" : "callbackWithoutUserData", "symbol" : "Gst.MemoryUnmapFullFunction" }, - { - "cIdentifier" : "gst_message_new_device_removed", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?,device:Device))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_device_removed" - }, - { - "cIdentifier" : "gst_message_new_duration_changed", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_duration_changed" - }, - { - "cIdentifier" : "gst_message_new_element", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?,structure:Structure))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_element" - }, - { - "cIdentifier" : "gst_message_new_eos", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_eos" - }, - { - "cIdentifier" : "gst_message_new_latency", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_latency" - }, - { - "cIdentifier" : "gst_message_new_new_clock", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?,clock:Clock))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_new_clock" - }, - { - "cIdentifier" : "gst_message_new_reset_time", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?,runningTime:UInt))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_reset_time" - }, - { - "cIdentifier" : "gst_message_new_segment_start", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?,format:Format,position:Int))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_segment_start" - }, - { - "cIdentifier" : "gst_message_new_state_dirty", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_state_dirty" - }, - { - "cIdentifier" : "gst_message_new_stream_start", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_stream_start" - }, - { - "cIdentifier" : "gst_message_new_streams_selected", - "detail" : "Swift signature 'init(throws:false|ret:Void|(src:Object?,collection:StreamCollection))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Message.gst_message_new_streams_selected" - }, { "cIdentifier" : "gst_message_new_error", "detail" : "parameter 'error': 'GLib.Error' shadows reserved type 'Error'", @@ -750,12 +648,6 @@ "reason" : "nameCollision", "symbol" : "Gst.Query.gst_query_new_drain" }, - { - "cIdentifier" : "gst_query_new_duration", - "detail" : "Swift signature 'init(throws:false|ret:Void|(format:Format))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Query.gst_query_new_duration" - }, { "cIdentifier" : "gst_query_new_formats", "detail" : "Swift signature 'init(throws:false|ret:Void|())' already emitted by an earlier symbol", @@ -768,30 +660,12 @@ "reason" : "nameCollision", "symbol" : "Gst.Query.gst_query_new_latency" }, - { - "cIdentifier" : "gst_query_new_position", - "detail" : "Swift signature 'init(throws:false|ret:Void|(format:Format))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Query.gst_query_new_position" - }, { "cIdentifier" : "gst_query_new_scheduling", "detail" : "Swift signature 'init(throws:false|ret:Void|())' already emitted by an earlier symbol", "reason" : "nameCollision", "symbol" : "Gst.Query.gst_query_new_scheduling" }, - { - "cIdentifier" : "gst_query_new_seeking", - "detail" : "Swift signature 'init(throws:false|ret:Void|(format:Format))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Query.gst_query_new_seeking" - }, - { - "cIdentifier" : "gst_query_new_segment", - "detail" : "Swift signature 'init(throws:false|ret:Void|(format:Format))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Query.gst_query_new_segment" - }, { "cIdentifier" : "gst_query_new_selectable", "detail" : "Swift signature 'init(throws:false|ret:Void|())' already emitted by an earlier symbol", @@ -864,12 +738,6 @@ "reason" : "constructorOutParams", "symbol" : "Gst.Structure.from_string" }, - { - "cIdentifier" : "gst_structure_new_static_str_empty", - "detail" : "Swift signature 'init(throws:false|ret:Void|(name:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Structure.gst_structure_new_static_str_empty" - }, { "cIdentifier" : "GstSystemClockClass", "detail" : "GObject class struct for 'SystemClock'", @@ -960,66 +828,6 @@ "reason" : "gtypeStruct", "symbol" : "Gst.URIHandlerInterface" }, - { - "cIdentifier" : "gst_uri_construct", - "detail" : "Swift signature 'construct(throws:false|ret:String|(`protocol`:String,location:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_construct" - }, - { - "cIdentifier" : "gst_uri_from_string", - "detail" : "Swift signature 'fromString(throws:false|ret:Uri?|(uri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_from_string" - }, - { - "cIdentifier" : "gst_uri_from_string_escaped", - "detail" : "Swift signature 'fromStringEscaped(throws:false|ret:Uri?|(uri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_from_string_escaped" - }, - { - "cIdentifier" : "gst_uri_get_location", - "detail" : "Swift signature 'getLocation(throws:false|ret:String?|(uri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_get_location" - }, - { - "cIdentifier" : "gst_uri_get_protocol", - "detail" : "Swift signature 'getProtocol(throws:false|ret:String?|(uri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_get_protocol" - }, - { - "cIdentifier" : "gst_uri_has_protocol", - "detail" : "Swift signature 'hasProtocol(throws:false|ret:Bool|(uri:String,`protocol`:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_has_protocol" - }, - { - "cIdentifier" : "gst_uri_is_valid", - "detail" : "Swift signature 'isValid(throws:false|ret:Bool|(uri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_is_valid" - }, - { - "cIdentifier" : "gst_uri_join_strings", - "detail" : "Swift signature 'joinStrings(throws:false|ret:String?|(baseUri:String,refUri:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_join_strings" - }, - { - "cIdentifier" : "gst_uri_protocol_is_supported", - "detail" : "Swift signature 'protocolIsSupported(throws:false|ret:Bool|(type:URIType,`protocol`:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_protocol_is_supported" - }, - { - "cIdentifier" : "gst_uri_protocol_is_valid", - "detail" : "Swift signature 'protocolIsValid(throws:false|ret:Bool|(`protocol`:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gst.Uri.gst_uri_protocol_is_valid" - }, { "cIdentifier" : "GstValueTable", "detail" : "no GType registration", @@ -3645,7 +3453,7 @@ ], "module" : "Gst", "stats" : { - "boundCallables" : 1095, + "boundCallables" : 1115, "boundCallbacks" : 79, "boundSignals" : 23, "boundTypes" : 422, diff --git a/regression/tier6/Gtk.json b/regression/tier6/Gtk.json index 14456ab..7fd20e9 100644 --- a/regression/tier6/Gtk.json +++ b/regression/tier6/Gtk.json @@ -210,12 +210,6 @@ "reason" : "gtypeStruct", "symbol" : "Gtk.BuilderScopeInterface" }, - { - "cIdentifier" : "gtk_button_new_with_mnemonic", - "detail" : "Swift signature 'init(throws:false|ret:Void|(label:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.Button.gtk_button_new_with_mnemonic" - }, { "cIdentifier" : "GtkButtonClass", "detail" : "GObject class struct for 'Button'", @@ -230,7 +224,7 @@ }, { "cIdentifier" : "gtk_cclosure_expression_new", - "detail" : "parameter 'marshal': callback 'ClosureMarshal' param 'closure' unmappable: unresolved type 'Gtk.Closure'", + "detail" : "parameter 'marshal': callback 'ClosureMarshal' param 'param_values' unmappable: C array bridging not yet implemented", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.CClosureExpression.new" }, @@ -324,12 +318,6 @@ "reason" : "gtypeStruct", "symbol" : "Gtk.CenterLayoutClass" }, - { - "cIdentifier" : "gtk_check_button_new_with_mnemonic", - "detail" : "Swift signature 'init(throws:false|ret:Void|(label:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.CheckButton.gtk_check_button_new_with_mnemonic" - }, { "cIdentifier" : "GtkCheckButtonClass", "detail" : "GObject class struct for 'CheckButton'", @@ -468,12 +456,6 @@ "reason" : "nameCollision", "symbol" : "Gtk.ComboBox.gtk_combo_box_new_with_entry" }, - { - "cIdentifier" : "gtk_combo_box_new_with_model_and_entry", - "detail" : "Swift signature 'init(throws:false|ret:Void|(model:TreeModel))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.ComboBox.gtk_combo_box_new_with_model_and_entry" - }, { "cIdentifier" : "GtkComboBoxClass", "detail" : "GObject class struct for 'ComboBox'", @@ -791,12 +773,6 @@ "reason" : "gtypeStruct", "symbol" : "Gtk.EveryFilterClass" }, - { - "cIdentifier" : "gtk_expander_new_with_mnemonic", - "detail" : "Swift signature 'init(throws:false|ret:Void|(label:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.Expander.gtk_expander_new_with_mnemonic" - }, { "cIdentifier" : "filters", "detail" : "property type 'ListModel' has no GValue support and no matching getter= method", @@ -1091,12 +1067,6 @@ "reason" : "gtypeStruct", "symbol" : "Gtk.KeyvalTriggerClass" }, - { - "cIdentifier" : "gtk_label_new_with_mnemonic", - "detail" : "Swift signature 'init(throws:false|ret:Void|(str:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.Label.gtk_label_new_with_mnemonic" - }, { "cIdentifier" : "GtkLayoutChildClass", "detail" : "GObject class struct for 'LayoutChild'", @@ -1367,12 +1337,6 @@ "reason" : "plainRecord", "symbol" : "Gtk.PageRange" }, - { - "cIdentifier" : "gtk_paper_size_get_default", - "detail" : "Swift signature 'getDefault(throws:false|ret:String|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.PaperSize.gtk_paper_size_get_default" - }, { "cIdentifier" : "GtkPasswordEntryBufferClass", "detail" : "GObject class struct for 'PasswordEntryBuffer'", @@ -1762,12 +1726,6 @@ "reason" : "plainRecord", "symbol" : "Gtk.TextViewPrivate" }, - { - "cIdentifier" : "gtk_toggle_button_new_with_mnemonic", - "detail" : "Swift signature 'init(throws:false|ret:Void|(label:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.ToggleButton.gtk_toggle_button_new_with_mnemonic" - }, { "cIdentifier" : "GtkToggleButtonClass", "detail" : "GObject class struct for 'ToggleButton'", @@ -1864,18 +1822,6 @@ "reason" : "arrayBridgingUnimplemented", "symbol" : "Gtk.TreePath.new_from_indicesv" }, - { - "cIdentifier" : "gtk_tree_row_reference_deleted", - "detail" : "Swift signature 'deleted(throws:false|ret:Void|(proxy:GLibObject,path:TreePath))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.TreeRowReference.gtk_tree_row_reference_deleted" - }, - { - "cIdentifier" : "gtk_tree_row_reference_inserted", - "detail" : "Swift signature 'inserted(throws:false|ret:Void|(proxy:GLibObject,path:TreePath))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Gtk.TreeRowReference.gtk_tree_row_reference_inserted" - }, { "cIdentifier" : "GtkTreeSortableIface", "detail" : "GObject class struct for 'TreeSortable'", @@ -2178,31 +2124,31 @@ }, { "cIdentifier" : "gtk_alert_dialog_choose", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.choose" }, { "cIdentifier" : "gtk_font_dialog_choose_face", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.choose_face" }, { "cIdentifier" : "gtk_font_dialog_choose_family", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.choose_family" }, { "cIdentifier" : "gtk_font_dialog_choose_font", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.choose_font" }, { "cIdentifier" : "gtk_font_dialog_choose_font_and_features", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.choose_font_and_features" }, @@ -2214,7 +2160,7 @@ }, { "cIdentifier" : "gtk_color_dialog_choose_rgba", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.choose_rgba" }, @@ -3138,13 +3084,13 @@ }, { "cIdentifier" : "gtk_file_launcher_launch", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.launch" }, { "cIdentifier" : "gtk_uri_launcher_launch", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.launch" }, @@ -3198,31 +3144,31 @@ }, { "cIdentifier" : "gtk_file_dialog_open", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.open" }, { "cIdentifier" : "gtk_file_launcher_open_containing_folder", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.open_containing_folder" }, { "cIdentifier" : "gtk_file_dialog_open_multiple", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.open_multiple" }, { "cIdentifier" : "gtk_file_dialog_open_multiple_text_files", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.open_multiple_text_files" }, { "cIdentifier" : "gtk_file_dialog_open_text_file", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.open_text_file" }, @@ -3252,7 +3198,7 @@ }, { "cIdentifier" : "gtk_print_dialog_print", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.print" }, @@ -3282,7 +3228,7 @@ }, { "cIdentifier" : "gtk_print_dialog_print_file", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.print_file" }, @@ -3402,25 +3348,25 @@ }, { "cIdentifier" : "gtk_file_dialog_save", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.save" }, { "cIdentifier" : "gtk_file_dialog_save_text_file", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.save_text_file" }, { "cIdentifier" : "gtk_file_dialog_select_folder", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.select_folder" }, { "cIdentifier" : "gtk_file_dialog_select_multiple_folders", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.select_multiple_folders" }, @@ -3672,7 +3618,7 @@ }, { "cIdentifier" : "gtk_print_dialog_setup", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.setup" }, @@ -3684,7 +3630,7 @@ }, { "cIdentifier" : "gtk_show_uri_full", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Gtk.AsyncResult'", + "detail" : "callback param 'callback' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "Gtk.show_uri_full" }, @@ -3817,7 +3763,7 @@ ], "module" : "Gtk", "stats" : { - "boundCallables" : 3190, + "boundCallables" : 3196, "boundCallbacks" : 47, "boundSignals" : 345, "boundTypes" : 589, diff --git a/regression/tier6/Pango.json b/regression/tier6/Pango.json index c1e744f..9d64644 100644 --- a/regression/tier6/Pango.json +++ b/regression/tier6/Pango.json @@ -48,12 +48,6 @@ "reason" : "plainRecord", "symbol" : "Pango.AttrLanguage" }, - { - "cIdentifier" : "pango_attr_list_from_string", - "detail" : "Swift signature 'fromString(throws:false|ret:AttrList?|(text:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Pango.AttrList.pango_attr_list_from_string" - }, { "cIdentifier" : "PangoAttrShape", "detail" : "no GType registration", @@ -96,12 +90,6 @@ "reason" : "gtypeStruct", "symbol" : "Pango.FontClass" }, - { - "cIdentifier" : "pango_font_description_from_string", - "detail" : "Swift signature 'fromString(throws:false|ret:FontDescription|(str:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Pango.FontDescription.pango_font_description_from_string" - }, { "cIdentifier" : "PangoFontFaceClass", "detail" : "GObject class struct for 'FontFace'", @@ -162,18 +150,6 @@ "reason" : "plainRecord", "symbol" : "Pango.GlyphVisAttr" }, - { - "cIdentifier" : "pango_language_from_string", - "detail" : "Swift signature 'fromString(throws:false|ret:Language?|(language:String?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Pango.Language.pango_language_from_string" - }, - { - "cIdentifier" : "pango_language_get_default", - "detail" : "Swift signature 'getDefault(throws:false|ret:Language|())' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Pango.Language.pango_language_get_default" - }, { "cIdentifier" : "PangoLayoutClass", "detail" : "GObject class struct for 'Layout'", @@ -204,12 +180,6 @@ "reason" : "plainRecord", "symbol" : "Pango.RendererPrivate" }, - { - "cIdentifier" : "pango_tab_array_from_string", - "detail" : "Swift signature 'fromString(throws:false|ret:TabArray?|(text:String))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Pango.TabArray.pango_tab_array_from_string" - }, { "cIdentifier" : "VERSION_STRING", "detail" : "Swift name 'versionString' conflicts with a function in this module", diff --git a/regression/tier6/Soup.json b/regression/tier6/Soup.json index 06a0411..27a948c 100644 --- a/regression/tier6/Soup.json +++ b/regression/tier6/Soup.json @@ -90,12 +90,6 @@ "reason" : "gtypeStruct", "symbol" : "Soup.ContentSnifferClass" }, - { - "cIdentifier" : "soup_cookie_parse", - "detail" : "Swift signature 'parse(throws:false|ret:Cookie?|(header:String,origin:GLib.Uri?))' already emitted by an earlier symbol", - "reason" : "nameCollision", - "symbol" : "Soup.Cookie.soup_cookie_parse" - }, { "cIdentifier" : "SoupCookieJarClass", "detail" : "GObject class struct for 'CookieJar'", @@ -258,7 +252,7 @@ }, { "cIdentifier" : "soup_message_body_append_take", - "detail" : "parameter 'data': scalar array C type 'guchar*' is not const (may be an output buffer)", + "detail" : "parameter 'data': scalar array with transfer-ownership=full", "reason" : "arrayBridgingUnimplemented", "symbol" : "Soup.append_take" }, @@ -496,18 +490,6 @@ "reason" : "movedToTargetMissing", "symbol" : "Soup.message_headers_iter_next" }, - { - "cIdentifier" : "soup_multipart_input_stream_next_part_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Soup.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Soup.next_part_async" - }, - { - "cIdentifier" : "soup_session_preconnect_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Soup.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Soup.preconnect_async" - }, { "cIdentifier" : "soup_websocket_extension_process_incoming_message", "detail" : "'header' has direction=inout", @@ -520,24 +502,6 @@ "reason" : "inoutParameter", "symbol" : "Soup.process_outgoing_message" }, - { - "cIdentifier" : "soup_session_send_and_read_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Soup.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Soup.send_and_read_async" - }, - { - "cIdentifier" : "soup_session_send_and_splice_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Soup.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Soup.send_and_splice_async" - }, - { - "cIdentifier" : "soup_session_send_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Soup.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Soup.send_async" - }, { "cIdentifier" : "soup_session_error_quark", "detail" : "moved-to target type 'SessionError' was not planned", @@ -646,12 +610,6 @@ "reason" : "containerType", "symbol" : "Soup.websocket_client_verify_handshake" }, - { - "cIdentifier" : "soup_session_websocket_connect_async", - "detail" : "parameter 'callback': callback 'AsyncReadyCallback' param 'res' unmappable: unresolved type 'Soup.AsyncResult'", - "reason" : "callbackWithoutUserData", - "symbol" : "Soup.websocket_connect_async" - }, { "cIdentifier" : "soup_websocket_error_quark", "detail" : "moved-to target type 'WebsocketError' was not planned", @@ -673,7 +631,7 @@ ], "module" : "Soup", "stats" : { - "boundCallables" : 310, + "boundCallables" : 316, "boundCallbacks" : 9, "boundSignals" : 40, "boundTypes" : 77,