From 5abb48e8898073adf5e24696fbf4ea8fefcf16f6 Mon Sep 17 00:00:00 2001 From: Brendan Szymanski Date: Sat, 18 Jul 2026 20:45:56 -0400 Subject: [PATCH] Fix Phase D signal/callback remediation defects Destroy-notify ABI fixed to GClosureNotify's real 2-arg signature and wired into every connect method (was leaking every _ClosureBox, and UB on non-x86_64 with the wrong arg count). Trampolines restore MainActor isolation via assumeIsolated, with narrowly-scoped nonisolated(unsafe) shadow copies to satisfy Swift 6's sending checker. Interface-signal rendering implemented and unit-tested. Dead code removed (SignalHandlePlan), destroyTrampoline made non-optional, D7 deferral documented in-code. CoverageStats gained boundCallbacks/boundSignals counters. Added SignalGenerationTests, InterfaceSignalGenerationTests, and CallbackGenerationTests (12 new tests, 187/187 total). Fixed the dead nonDetailedSignal smoke test to actually mutate a property and assert the closure fired. Callback-param planner-side binding (D4.3) stays disabled: enabling it trips a genuine Swift compiler crash on g_qsort_with_data's GCompareDataFunc parameter. The renderer-side box setup/release logic is implemented and unit-tested by constructing plans directly, bypassing the blocked planner path. Verified: swift test (187/187), compile-gate.sh 1 --fresh (PASS), smoke-test.sh --fresh (18/18). --- Sources/SwiftGtkGenCore/BindingPlan.swift | 121 +- Sources/SwiftGtkGenCore/PlanRenderer.swift | 426 ++++- Sources/SwiftGtkGenCore/Planner.swift | 232 ++- Sources/SwiftGtkGenCore/TypeMapper.swift | 61 +- Sources/SwiftGtkGenCore/TypeRegistry.swift | 13 + .../CallbackGenerationTests.swift | 167 ++ .../InterfaceSignalGenerationTests.swift | 78 + .../SignalGenerationTests.swift | 105 ++ docs/skip-baseline/tier1/GLib.json | 1478 +++++++++-------- docs/skip-baseline/tier1/GObject.json | 480 +++--- smoke/SmokeTests.swift | 85 +- 11 files changed, 2259 insertions(+), 987 deletions(-) create mode 100644 Tests/SwiftGtkGenCoreTests/CallbackGenerationTests.swift create mode 100644 Tests/SwiftGtkGenCoreTests/InterfaceSignalGenerationTests.swift create mode 100644 Tests/SwiftGtkGenCoreTests/SignalGenerationTests.swift diff --git a/Sources/SwiftGtkGenCore/BindingPlan.swift b/Sources/SwiftGtkGenCore/BindingPlan.swift index bffeb13..e9a99dc 100644 --- a/Sources/SwiftGtkGenCore/BindingPlan.swift +++ b/Sources/SwiftGtkGenCore/BindingPlan.swift @@ -17,6 +17,8 @@ public enum BindingCategory: String, Equatable, Sendable { case needsClass /// Boxed record — needs a record wrapper. case needsRecord + /// Callback type — needs a typealias before callables can use it. + case callback /// A type that will never be generated (foreign, unknown). case unavailable } @@ -46,6 +48,12 @@ public enum MarshalIn: Equatable, Sendable { case bitfieldRaw /// Pass the pointer of a boxed record wrapper. case boxedPointer + /// Box a Swift closure for C callback trampoline dispatch. + /// - Parameters: + /// - scope: The callback lifetime from the GIR `scope` attribute. + /// - destroyTrampoline: The per-signature destroy trampoline C name, + /// or `""` when no destroy is needed (namespace-level typealiases). + case callbackBox(scope: CallbackScope?, destroyTrampoline: String) /// Unsupported — causes the whole callable to be skipped. /// - Parameter reason: Why the parameter cannot be marshalled. case unsupported(reason: String) @@ -168,6 +176,8 @@ public enum SkipReason: String, Codable, CaseIterable, Sendable { /// `init` (an init cannot also return out-value tuples). The constructor /// is skipped. case constructorOutParams + /// A signal parameter or return type could not be mapped. + case signalUnmappableParam } /// A single skipped symbol: what was skipped, and why. @@ -203,7 +213,6 @@ public struct SkipEntry: Codable, Equatable, Sendable { /// /// Coverage is the fraction of introspectable callables that received a /// complete binding plan. The compile gate requires coverage to be -/// monotonically non-decreasing across changes. public struct CoverageStats: Codable, Equatable, Sendable { /// Number of callables successfully planned and emitted. public var boundCallables: Int @@ -213,19 +222,23 @@ public struct CoverageStats: Codable, Equatable, Sendable { public var boundTypes: Int /// Total introspectable types considered (bound + skipped). public var totalTypes: Int + /// Namespace-level callbacks successfully planned and emitted (D6). + public var boundCallbacks: Int + /// Total namespace-level callbacks considered (bound + skipped). + public var totalCallbacks: Int + /// GObject signals successfully planned and emitted (Phase D). + public var boundSignals: Int + /// Total signals considered (bound + skipped). + public var totalSignals: Int - /// Creates coverage statistics. - /// - /// - Parameters: - /// - boundCallables: Callables successfully planned and emitted. - /// - totalCallables: Total introspectable callables considered. - /// - boundTypes: Types successfully planned and emitted. - /// - totalTypes: Total introspectable types considered. - public init(boundCallables: Int = 0, totalCallables: Int = 0, boundTypes: Int = 0, totalTypes: Int = 0) { - self.boundCallables = boundCallables - self.totalCallables = totalCallables - self.boundTypes = boundTypes - self.totalTypes = totalTypes + public init(boundCallables: Int = 0, totalCallables: Int = 0, + boundTypes: Int = 0, totalTypes: Int = 0, + boundCallbacks: Int = 0, totalCallbacks: Int = 0, + boundSignals: Int = 0, totalSignals: Int = 0) { + self.boundCallables = boundCallables; self.totalCallables = totalCallables + self.boundTypes = boundTypes; self.totalTypes = totalTypes + self.boundCallbacks = boundCallbacks; self.totalCallbacks = totalCallbacks + self.boundSignals = boundSignals; self.totalSignals = totalSignals } } @@ -286,6 +299,8 @@ public enum TypePlan: Sendable { case record(RecordPlan) /// A callable (function, method, or constructor). case callable(CallablePlan) + /// A namespace-level callback typealias. + case callback(CallbackTypePlan) } /// The plan for a GIR enumeration: cases and alias variables (deduplicated @@ -391,6 +406,62 @@ public struct AliasPlan: Equatable, Sendable { } } +/// The plan for a GObject signal connection. +/// +/// Each signal on a class or interface generates a typed trampoline +/// (`@convention(c)` static func) and a `connect(…)` method that +/// boxes the Swift closure, passes it to `g_signal_connect_data`, +/// and returns a `SignalHandle`. +public struct SignalPlan: Equatable, Sendable { + /// The owning class's Swift name, e.g. `"Object"`. + public let owningClassName: String + /// The GIR signal name, e.g. `"clicked"`, `"notify"`. + public let girName: String + /// The camelCased Swift name, e.g. `"clicked"`. + public let swiftName: String + /// Whether the signal supports detail strings (`"notify::label"`). + public let isDetailed: Bool + /// The signal handler parameters (includes implicit instance param at cArgIndex 0). + public let parameters: [ParameterPlan] + /// The return mapping, or `nil` for `void`. + public let returnMapping: Mapping? + /// The `@convention(c)` trampoline's C-level name, unique per module. + /// Format: `"_trampoline_\(namespace)_\(owningClass)_\(girName)"`. + public let trampolineCName: String + /// Documentation from the GIR `` element. + public let doc: String? + + public init(owningClassName: String, girName: String, swiftName: String, + isDetailed: Bool = false, parameters: [ParameterPlan] = [], + returnMapping: Mapping? = nil, trampolineCName: String, + doc: String? = nil) { + self.owningClassName = owningClassName; self.girName = girName + self.swiftName = swiftName; self.isDetailed = isDetailed + self.parameters = parameters; self.returnMapping = returnMapping + self.trampolineCName = trampolineCName; self.doc = doc + } +} + + +/// The plan for a namespace-level callback type. +/// +/// Renders as both a C-compatible `@convention(c)` typealias for C callbacks +/// and a Swift-friendly `@escaping` typealias for use in generated connect methods. +public struct CallbackTypePlan: Equatable, Sendable { + /// The Swift type name, e.g. `"GClosureNotify"`. + public let name: String + /// The Swift closure form, e.g. `"@escaping (UnsafeMutableRawPointer?) -> Void"`. + public let swiftType: String + /// The C-compatible convention(c) form for trampoline signatures. + public let cSwiftType: String + /// Documentation from the GIR `` element. + public let doc: String? + + public init(name: String, swiftType: String, cSwiftType: String, doc: String? = nil) { + self.name = name; self.swiftType = swiftType; self.cSwiftType = cSwiftType; self.doc = doc + } +} + /// The plan for a GObject class wrapper. public struct ClassPlan: Equatable, Sendable { /// The Swift class name (unqualified), e.g. `"Object"`. @@ -417,6 +488,8 @@ public struct ClassPlan: Equatable, Sendable { public let functions: [CallablePlan] /// Planned GObject properties. public let properties: [PropertyPlan] + /// Planned GObject signals. + public let signals: [SignalPlan] /// Module-qualified names of implemented interfaces (e.g. ["GObject.TypePlugin"]). public let interfaces: [String] /// Documentation from the GIR `` element. @@ -429,6 +502,7 @@ public struct ClassPlan: Equatable, Sendable { interfaces: [String] = [], constructors: [CallablePlan] = [], methods: [CallablePlan] = [], functions: [CallablePlan] = [], properties: [PropertyPlan] = [], + signals: [SignalPlan] = [], doc: String? = nil) { self.name = name; self.cType = cType; self.parent = parent self.isOpen = isOpen; self.isAbstract = isAbstract @@ -437,6 +511,7 @@ public struct ClassPlan: Equatable, Sendable { self.interfaces = interfaces self.constructors = constructors; self.methods = methods self.functions = functions; self.properties = properties + self.signals = signals self.doc = doc } } @@ -472,6 +547,8 @@ public struct InterfacePlan: Equatable, Sendable { public let methods: [CallablePlan] /// Properties declared by this interface, rendered as protocol requirements. public let properties: [PropertyPlan] + /// Signals declared by this interface. + public let signals: [SignalPlan] /// The module-qualified Swift name, e.g. `"GObject.TypePlugin"`. /// Used to match against `ClassPlan.interfaces` entries. public let qualifiedName: String @@ -479,11 +556,13 @@ public struct InterfacePlan: Equatable, Sendable { public init(name: String, cType: String, prereqs: [String] = [], getTypeFunction: String? = nil, methods: [CallablePlan] = [], - properties: [PropertyPlan] = [], qualifiedName: String = "", + properties: [PropertyPlan] = [], signals: [SignalPlan] = [], + qualifiedName: String = "", doc: String? = nil) { self.name = name; self.cType = cType; self.prereqs = prereqs self.getTypeFunction = getTypeFunction; self.methods = methods - self.properties = properties; self.qualifiedName = qualifiedName + self.properties = properties; self.signals = signals + self.qualifiedName = qualifiedName self.doc = doc } } @@ -626,15 +705,23 @@ public struct ParameterPlan: Equatable, Sendable { public let mapping: Mapping /// `true` when this parameter is the implicit instance (`self`). public let isInstanceParameter: Bool - /// `true` if this parameter has `direction="out"` and will be returned from /// the Swift function rather than passed as an argument. public let isOutParameter: Bool + /// For callback-box params: the C arg index of the separate user-data + /// parameter this callback feeds. `nil` when this param doubles as + /// its own user-data (`closureIndex == cArgIndex`). + public let closureIndex: Int? + /// For callback-box params: the C arg index of the separate DestroyNotify + /// parameter. `nil` when none. + public let destroyIndex: Int? public init(swiftName: String, cArgIndex: Int, mapping: Mapping, - isInstanceParameter: Bool = false, isOutParameter: Bool = false) { + isInstanceParameter: Bool = false, isOutParameter: Bool = false, + closureIndex: Int? = nil, destroyIndex: Int? = nil) { self.swiftName = swiftName; self.cArgIndex = cArgIndex self.mapping = mapping; self.isInstanceParameter = isInstanceParameter self.isOutParameter = isOutParameter + self.closureIndex = closureIndex; self.destroyIndex = destroyIndex } } diff --git a/Sources/SwiftGtkGenCore/PlanRenderer.swift b/Sources/SwiftGtkGenCore/PlanRenderer.swift index 3a3c7f7..fd5950d 100644 --- a/Sources/SwiftGtkGenCore/PlanRenderer.swift +++ b/Sources/SwiftGtkGenCore/PlanRenderer.swift @@ -43,6 +43,7 @@ public func renderModule(_ plan: ModulePlan) -> [String: String] { var constants: [(name: String, body: String)] = [] var functions: [(name: String, body: String)] = [] + var callbacks: [(name: String, body: String)] = [] for typePlan in plan.types { switch typePlan { @@ -50,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 .callback(let p): + callbacks.append((p.name, renderCallbackType(p))) default: let (baseName, body) = renderTypePlan(typePlan) files["\(baseName).swift"] = header + body + "\n" @@ -62,9 +65,28 @@ public func renderModule(_ plan: ModulePlan) -> [String: String] { if !functions.isEmpty { files["Functions.swift"] = header + mergedFileBody(functions) } + if !callbacks.isEmpty { + files["Callbacks.swift"] = header + mergedFileBody(callbacks) + } - // Always emit the per-module pointer-cast helpers. - files["Support.swift"] = renderSupport(moduleName: plan.module) + // Determine if any class/interface has signals — the signal runtime + // (ClosureBox, SignalHandle, destroy trampoline) is only needed + // when signals or callback-param callables are present. + let hasSignals = plan.types.contains { typePlan in + switch typePlan { + case .class(let p): return !p.signals.isEmpty + case .interface(let p): return !p.signals.isEmpty + default: return false + } + } + let hasCallbacks = plan.types.contains { typePlan in + if case .callable(let p) = typePlan { + return p.parameters.contains { if case .callbackBox(_, _) = $0.mapping.marshalIn { true } else { false } } + } + return false + } + + files["Support.swift"] = renderSupport(moduleName: plan.module, hasSignals: hasSignals, hasCallbackBoxes: hasCallbacks) for filename in files.keys { precondition(isValidGeneratedFileName(filename), @@ -121,12 +143,7 @@ private func leadingNameWord(_ name: String) -> String { return word.isEmpty ? String(trimmed) : String(word) } -/// Renders the per-module support file: the overloaded `_instancePointer` -/// helper that reinterprets a wrapper's raw `pointer` as the specific C pointer -/// type each C call expects. Two overloads let call-site overload resolution -/// pick `OpaquePointer` (opaque C structs) or `UnsafeMutablePointer` -/// (complete C structs) without the generator needing to know which a type is. -private func renderSupport(moduleName: String) -> String { +private func renderSupport(moduleName: String, hasSignals: Bool = false, hasCallbackBoxes: Bool = false) -> String { let glibError: String if moduleName == "GLib" { glibError = """ @@ -180,6 +197,85 @@ private func renderSupport(moduleName: String) -> String { } else { gtypeConstants = "" } + let closureBoxSupport: String + if hasCallbackBoxes || hasSignals { + closureBoxSupport = """ + + // MARK: - Closure box for callback/signal dispatch + /// Boxes a Swift closure for C callback trampoline dispatch. + /// `@MainActor` because the stored closure is always accessed from + /// `MainActor.assumeIsolated` in the trampoline or from the + /// `@MainActor` connect method. + @MainActor + final class _ClosureBox { + let closure: T + init(_ c: T) { closure = c } + } + + """ + } else { + closureBoxSupport = "" + } + + let signalSupport: String + if hasSignals { + signalSupport = """ + + /// A handle returned by `connect` methods, wrapping a GObject signal + /// handler ID. Disconnecting marks the handle as disconnected to + /// prevent double-disconnect. + /// - Note: Uses `mutating func disconnect()` + `isDisconnected` flag + /// as a fallback per Phase D contingency; `~Copyable` would also work. + public struct SignalHandle { + public let id: UInt + public let instance: UnsafeMutableRawPointer + private var isDisconnected: Bool = false + public init(id: UInt, instance: UnsafeMutableRawPointer) { self.id = id; self.instance = instance } + public mutating func disconnect() { + guard !isDisconnected else { return } + isDisconnected = true + _sgtk_signal_handler_disconnect(instance, numericCast(id)) + } + } + + /// Implements the `GClosureNotify` C callback signature + /// (two args: data pointer + GClosure pointer). + /// + /// Never emitted with `@_cdecl` — per-call-site wrapping via a + /// `@convention(c)` literal closure avoids duplicate-symbol link + /// errors when multiple modules with signals link together. + public nonisolated func _sgtk_destroy_notify_impl( + _ data: UnsafeMutableRawPointer?, + _ closure: UnsafeMutableRawPointer? + ) { + guard let data else { return } + _ = Unmanaged.fromOpaque(data).takeRetainedValue() + } + """ + } else { + signalSupport = "" + } + + let primitiveShims: String + if moduleName == "GObject" && hasSignals { + primitiveShims = """ + + // MARK: - manual primitives (Phase E: replace with planned bindings) + + @_silgen_name("g_signal_connect_data") + public nonisolated func _sgtk_signal_connect_data( + _ instance: UnsafeMutableRawPointer, _ detailedSignal: UnsafePointer, + _ cHandler: UnsafeRawPointer, _ data: UnsafeMutableRawPointer?, + _ destroyData: UnsafeRawPointer?, _ connectFlags: UInt32 + ) -> UInt + @_silgen_name("g_signal_handler_disconnect") + public nonisolated func _sgtk_signal_handler_disconnect( + _ instance: UnsafeMutableRawPointer, _ handlerId: UInt + ) + """ + } else { + primitiveShims = "" + } return """ // Generated by SwiftGtkGen. DO NOT EDIT. @@ -225,7 +321,7 @@ private func renderSupport(moduleName: String) -> String { func _rawPointer(_ p: OpaquePointer) -> UnsafeMutableRawPointer { UnsafeMutableRawPointer(p) } - \(glibError)\(gtypeConstants) + \(glibError)\(gtypeConstants)\(closureBoxSupport)\(signalSupport)\(primitiveShims) """ } @@ -245,6 +341,7 @@ 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 .callback(let p): return (p.name, renderCallbackType(p)) } } @@ -332,6 +429,27 @@ private func renderAlias(_ plan: AliasPlan) -> String { return lines.joined(separator: "\n") + "\n" } +// ── Callback typealias ── + +/// Renders a namespace-level callback type as both a C-compatible +/// `@convention(c)` typealias and a Swift-friendly `@escaping` typealias. +/// +/// Example output: +/// ```swift +/// /// Documentation +/// public typealias GClosureNotify = @convention(c) (UnsafeMutableRawPointer?) -> Void +/// public typealias GClosureNotifySwift = (UnsafeMutableRawPointer?) -> Void +/// ``` +private func renderCallbackType(_ plan: CallbackTypePlan) -> String { + var lines: [String] = [] + if let doc = plan.doc { + lines.append(contentsOf: renderDocComment(doc)) + } + lines.append("public typealias \(plan.name) = \(plan.cSwiftType)") + lines.append("public typealias \(plan.name)Swift = \(plan.swiftType)") + return lines.joined(separator: "\n") + "\n" +} + // ── Record (boxed) ── private func renderRecord(_ plan: RecordPlan) -> String { @@ -381,6 +499,12 @@ private func renderRecord(_ plan: RecordPlan) -> String { private func renderInterface(_ plan: InterfacePlan) -> String { var lines: [String] = [] + // Signal trampolines at file scope (same pattern as classes) + for sig in plan.signals { + lines.append(contentsOf: renderSignalTrampoline(sig)) + lines.append("") + } + if let doc = plan.doc { lines.append(contentsOf: renderDocComment(doc)) } @@ -399,6 +523,18 @@ private func renderInterface(_ plan: InterfacePlan) -> String { lines.append(contentsOf: renderPropertyRequirement(prop)) } lines.append("}") + + // Protocol extension with signal connect methods + if !plan.signals.isEmpty { + lines.append("") + lines.append("extension \(plan.name) {") + for sig in plan.signals { + lines.append(contentsOf: renderSignalConnect(sig, className: plan.name)) + lines.append("") + } + lines.append("}") + } + return lines.joined(separator: "\n") + "\n" } @@ -435,10 +571,17 @@ private func renderClass(_ plan: ClassPlan) -> String { lines.append(contentsOf: renderDocComment(doc)) } + // ── Signal trampolines (file-level @_cdecl) ── + for sig in plan.signals { + lines.append(contentsOf: renderSignalTrampoline(sig)) + lines.append("") + } + let access = plan.isOpen ? "open" : "public" let parentDecl: String if let parent = plan.parent { let ifaces = plan.interfaces.isEmpty ? "" : ", \(plan.interfaces.joined(separator: ", "))" + parentDecl = ": \(parent)\(ifaces)" } else if !plan.interfaces.isEmpty { parentDecl = ": \(plan.interfaces.joined(separator: ", "))" @@ -520,26 +663,179 @@ private func renderClass(_ plan: ClassPlan) -> String { lines.append("") } + // ── Signals ── + for sig in plan.signals { + lines.append(contentsOf: renderSignalConnect(sig, className: plan.name)) + lines.append("") + } + lines.append("}") return lines.joined(separator: "\n") + "\n" } -// ── Callable (function) ── +// ── Signal rendering ── -/// The Swift parameter list for a callable (excludes the instance parameter). +/// Renders a `@_cdecl nonisolated` trampoline for a GObject signal. +/// +/// The `@_cdecl` ABI is required because C calls this function via a raw +/// function pointer; Swift's native calling convention would SIGILL. +/// The body wraps wrapper construction and the closure call in +/// `MainActor.assumeIsolated` per AGENTS Top Risk #1 — traps if C +/// ever fires the signal off the main thread. +private func renderSignalTrampoline(_ plan: SignalPlan) -> [String] { + var lines: [String] = [] + let instanceParams = plan.parameters.filter { $0.isInstanceParameter } + let realParams = plan.parameters.filter { !$0.isInstanceParameter } + let allParams = instanceParams + realParams + + // User-facing closure type stored in ClosureBox (typed wrappers) + let closureParamTypes = allParams.map { $0.mapping.swiftType } + let closureRet = plan.returnMapping?.swiftType ?? "Void" + let closureParams = closureParamTypes.isEmpty ? "" : closureParamTypes.joined(separator: ", ") + let closureType = "(\(closureParams)) -> \(closureRet)" + + // C parameter declaration for the @_cdecl function + var cParamStrs: [String] = [] + cParamStrs.append("_ instance: UnsafeMutableRawPointer") + for (idx, p) in realParams.enumerated() { + let cType = p.mapping.cSwiftType.replacingOccurrences(of: "?", with: "") + cParamStrs.append("_ p\(idx + 1): \(cType)") + } + cParamStrs.append("_ data: UnsafeMutableRawPointer?") + let cDecl = cParamStrs.joined(separator: ", ") + + // Wrapper construction for each parameter inside MainActor.assumeIsolated. + // The raw C parameters (`instance`, `p1`, `p2`, ...) belong to this + // `nonisolated` trampoline's isolation domain. Swift 6's region-based + // sending checker flags capturing them directly into the `@MainActor` + // closure below as a potential data race, even though they are trivial + // pointer values with no live aliasing concern here (C never touches + // them again once the trampoline is invoked). `nonisolated(unsafe)` + // shadow copies sidestep the checker for this documented-safe case. + var shadowLines: [String] = [] + var wrapperLines: [String] = [] + for (i, p) in allParams.enumerated() { + let rawName = i == 0 ? "instance" : "p\(i)" + let shadowName = "captured\(rawName.prefix(1).uppercased())\(rawName.dropFirst())" + shadowLines.append("nonisolated(unsafe) let \(shadowName) = \(rawName)") + wrapperLines.append("let w\(i) = \(renderWrapperExpr(for: p, rawName: shadowName))") + } + let wrapperRefs = (0..>.fromOpaque(data).takeUnretainedValue()") + lines.append(shadowBody) + lines.append(" MainActor.assumeIsolated {") + lines.append(wrapperBody) + lines.append(" }") + lines.append("}") + return lines +} + +/// Renders a single wrapper-expression for a signal parameter: the Swift +/// expression that converts a raw C argument (managed by the trampoline) +/// into a typed Swift wrapper. Extracted from renderSignalTrampoline. +private func renderWrapperExpr(for p: ParameterPlan, rawName: String) -> String { + if p.isInstanceParameter { + return "\(p.mapping.swiftType)(retaining: \(rawName))" + } + switch p.mapping.marshalIn { + case .boxedPointer, .objectPointer: + return "\(p.mapping.swiftType)(retaining: \(rawName))" + case .stringToC: + return "String(cString: \(rawName))" + case .boolToGboolean: + return "\(rawName) != 0" + default: + return rawName + } +} + +/// Renders the `connect` method. Boxes the user's typed handler +/// directly — wrapper construction from raw C args is handled by the +/// trampoline under `MainActor.assumeIsolated`. +private func renderSignalConnect(_ plan: SignalPlan, className: String) -> [String] { + var lines: [String] = [] + let instanceParams = plan.parameters.filter { $0.isInstanceParameter } + let realParams = plan.parameters.filter { !$0.isInstanceParameter } + + // User-facing closure type (typed wrappers) — same as the trampoline's closureType + let closureParamTypes = instanceParams.map { $0.mapping.swiftType } + + realParams.map { $0.mapping.swiftType } + let closureRet = plan.returnMapping?.swiftType ?? "Void" + let closureParams = closureParamTypes.isEmpty ? "" : closureParamTypes.joined(separator: ", ") + let closureType = "(\(closureParams)) -> \(closureRet)" + + // Build @convention(c) type for the trampoline's unsafeBitCast + let cTypes = ["UnsafeMutableRawPointer"] + realParams.map { p in + p.mapping.cSwiftType.replacingOccurrences(of: "?", with: "") + } + ["UnsafeMutableRawPointer?"] + let cTypeStr = cTypes.joined(separator: ", ") + + let connectName = "connect" + plan.swiftName.prefix(1).uppercased() + plan.swiftName.dropFirst() + let detailParam = plan.isDetailed ? "detail: String?, " : "" + let detailBody: String + if plan.isDetailed { + detailBody = "let signalName: String = detail.map { \"\(plan.girName)::\\($0)\" } ?? \"\(plan.girName)\"" + } else { + detailBody = "let signalName = \"\(plan.girName)\"" + } + + if let doc = plan.doc { + lines.append(contentsOf: renderDocComment(doc).map { " \($0)" }) + } + lines.append(" public func \(connectName)(\(detailParam)_ handler: @escaping \(closureType)) -> SignalHandle {") + lines.append(" let box = _ClosureBox(handler)") + lines.append(" let dataPtr = Unmanaged.passRetained(box).toOpaque()") + lines.append(" let destroyFn: @convention(c) (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) -> Void = { data, _ in") + lines.append(" _sgtk_destroy_notify_impl(data, nil)") + lines.append(" }") + lines.append(" let ptr = self.pointer") + lines.append(" \(detailBody)") + lines.append(" return signalName.withCString { cName in") + lines.append(" let id = _sgtk_signal_connect_data(ptr, cName, unsafeBitCast(\(plan.trampolineCName) as (@convention(c) (\(cTypeStr)) -> Void), to: UnsafeRawPointer.self), dataPtr, unsafeBitCast(destroyFn as (@convention(c) (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) -> Void), to: UnsafeRawPointer.self), 0)") + lines.append(" return SignalHandle(id: id, instance: ptr)") + lines.append(" }") + lines.append(" }") + return lines +} private func swiftSignature(_ plan: CallablePlan) -> String { plan.parameters.filter { !$0.isInstanceParameter && !$0.isOutParameter }.map { param in - "\(param.swiftName): \(param.mapping.swiftType)" + let typeStr: String + if param.mapping.category == .callback { + typeStr = "@escaping \(param.mapping.swiftType)" + } else { + typeStr = param.mapping.swiftType + } + return "\(param.swiftName): \(typeStr)" }.joined(separator: ", ") } /// Builds the C call: the C-function-call string with each argument marshalled, /// plus the string parameters that must be wrapped in `withCString`. The /// instance parameter — if any — is passed as `self.pointer`. +/// +/// Callback-box parameters: the data pointer replaces the closure arg at the +/// callback's cArgIndex, and also replaces any separate user-data slot +/// identified by `closureIndex`. private func cArguments(_ plan: CallablePlan, error: Bool = false) -> (cCall: String, stringParams: [(cName: String, swiftName: String)]) { var stringParams: [(cName: String, swiftName: String)] = [] var cArgExprs: [String] = [] var outIndex = 0 + + // Build map: closureIndex -> callback data ptr name, so separate user-data + // params get replaced with the box pointer. + var closureDataMap: [Int: String] = [:] + for p in plan.parameters { + if case .callbackBox(_, _) = p.mapping.marshalIn, let ci = p.closureIndex { + let base = p.swiftName.replacingOccurrences(of: "`", with: "") + closureDataMap[ci] = "\(base)Data" + } + } + for param in plan.parameters { if param.isOutParameter { cArgExprs.append("&out\(outIndex)") @@ -550,6 +846,8 @@ private func cArguments(_ plan: CallablePlan, error: Bool = false) -> (cCall: St let cName = "cString\(stringParams.count)" stringParams.append((cName: cName, swiftName: param.swiftName)) cArgExprs.append(cName) + } else if let dataPtrName = closureDataMap[param.cArgIndex], !isCallbackBox(param) { + cArgExprs.append(dataPtrName) } else { cArgExprs.append(marshalCallArg(param)) } @@ -558,6 +856,36 @@ private func cArguments(_ plan: CallablePlan, error: Bool = false) -> (cCall: St return ("\(plan.cIdentifier)(\(cArgExprs.joined(separator: ", ")))", stringParams) } +/// Emits setup statements for callback-box parameters: box the closure, + +private func isCallbackBox(_ param: ParameterPlan) -> Bool { + if case .callbackBox(_, _) = param.mapping.marshalIn { return true } + return false +} +private func callbackBoxSetup(_ plan: CallablePlan, indent: String) -> [String] { + var lines: [String] = [] + for p in plan.parameters { + if case .callbackBox(_, _) = p.mapping.marshalIn { + let base = p.swiftName.replacingOccurrences(of: "`", with: "") + lines.append("\(indent)let \(base)Box = _ClosureBox(\(p.swiftName))") + lines.append("\(indent)let \(base)Data = Unmanaged.passRetained(\(base)Box).toOpaque()") + } + } + return lines +} + +/// Emits release statements for scope==.call callback-box parameters. +private func callbackBoxRelease(_ plan: CallablePlan, indent: String) -> [String] { + var lines: [String] = [] + for p in plan.parameters { + if case .callbackBox(let scope, _) = p.mapping.marshalIn, scope == .call { + let base = p.swiftName.replacingOccurrences(of: "`", with: "") + lines.append("\(indent)_ = Unmanaged<_ClosureBox<\(p.mapping.cSwiftType)>>.fromOpaque(\(base)Data).takeRetainedValue()") + } + } + return lines +} + /// The C type for an out-param's local variable declaration (the pointee type /// passed as `&local` to the C function). private func outParamLocalType(_ param: ParameterPlan) -> String { @@ -641,7 +969,7 @@ private func renderMultiStatementBody(_ plan: CallablePlan, indent: String) -> [ // Out-param locals: declare, pass `&`, extract after call let outParams = plan.parameters.filter(\.isOutParameter) - var localDecls: [String] = [] + var localDecls = callbackBoxSetup(plan, indent: indent) var outValues: [String] = [] for (idx, param) in outParams.enumerated() { localDecls.append("\(indent)var out\(idx): \(outParamLocalType(param)) = \(outParamInitValue(param))") @@ -662,6 +990,7 @@ private func renderMultiStatementBody(_ plan: CallablePlan, indent: String) -> [ postCall.append("\(indent) throw GLibError(consuming: e)") postCall.append("\(indent)}") } + postCall.append(contentsOf: callbackBoxRelease(plan, indent: indent)) // C pointer returns (object, string, boxed) are imported as optionals; // force-unwrap when the Swift type is non-optional (safe: error-check @@ -738,15 +1067,45 @@ private func renderCallExpression(_ plan: CallablePlan) -> String { /// Renders the `{ … }` body lines of a function or method (indented by /// `indent`). String parameters are wrapped in one `withCString` closure per -/// string, one level per line, each returning its inner result — the flat -/// single-expression form overwhelms the type-checker past ~2 nested closures. +/// string. Callback-box params add setup before the C call and release +/// after (for scope==.call). private func renderCallBody(_ plan: CallablePlan, indent: String) -> [String] { + let hasCallbacks = plan.parameters.contains { if case .callbackBox(_, _) = $0.mapping.marshalIn { true } else { false } } let (cCall, stringParams) = cArguments(plan) let hasReturn = plan.returnMapping != nil - let core = hasReturn ? "return \(marshalReturn(cCall, mapping: plan.returnMapping!))" : cCall - if stringParams.isEmpty { return ["\(indent)\(core)"] } + // When callbacks are present, emit setup / call / release / return + // instead of a single return-expression (release must run after C call). + let callStmt: String + let returnExprAfter: String? + if hasCallbacks && hasReturn { + callStmt = "\(indent)let __result = \(cCall)" + returnExprAfter = "\(indent)return \(marshalReturn("__result", mapping: plan.returnMapping!))" + } else if hasReturn { + callStmt = "\(indent)return \(marshalReturn(cCall, mapping: plan.returnMapping!))" + returnExprAfter = nil + } else { + callStmt = "\(indent)\(cCall)" + returnExprAfter = nil + } + // Simple path: no callbacks, no string params + if !hasCallbacks && stringParams.isEmpty { + return [callStmt] + } + + let setupStmts = callbackBoxSetup(plan, indent: indent) + let releaseStmts = callbackBoxRelease(plan, indent: indent) + + if stringParams.isEmpty && hasCallbacks { + var lines = setupStmts + lines.append(callStmt) + lines.append(contentsOf: releaseStmts) + if let ret = returnExprAfter { lines.append(ret) } + return lines + } + + // String params present — wrap in withCString closures var lines: [String] = [] var scope = indent let openerPrefix = hasReturn ? "return " : "" @@ -754,7 +1113,20 @@ private func renderCallBody(_ plan: CallablePlan, indent: String) -> [String] { lines.append("\(scope)\(openerPrefix)\(sp.swiftName).withCString { \(sp.cName) in") scope += " " } - lines.append("\(scope)\(core)") + for stmt in setupStmts { + let stripped = stmt.hasPrefix(indent) ? String(stmt.dropFirst(indent.count)) : stmt + lines.append("\(scope)\(stripped)") + } + let strippedCall = callStmt.hasPrefix(indent) ? String(callStmt.dropFirst(indent.count)) : callStmt + lines.append("\(scope)\(strippedCall)") + for stmt in releaseStmts { + let stripped = stmt.hasPrefix(indent) ? String(stmt.dropFirst(indent.count)) : stmt + lines.append("\(scope)\(stripped)") + } + if let ret = returnExprAfter { + let stripped = ret.hasPrefix(indent) ? String(ret.dropFirst(indent.count)) : ret + lines.append("\(scope)\(stripped)") + } for _ in stringParams { scope = String(scope.dropLast(4)) lines.append("\(scope)}") @@ -790,8 +1162,11 @@ private func renderThrowingBody(_ plan: CallablePlan, indent: String) -> [String ] let returnStmt = hasReturn ? ["\(indent)return \(marshalReturn(returnArg, mapping: plan.returnMapping!))"] : [] + let setupStmts = callbackBoxSetup(plan, indent: indent) + let releaseStmts = callbackBoxRelease(plan, indent: indent) + if stringParams.isEmpty { - return [errorDecl, cCallStmt] + errorCheck + returnStmt + return setupStmts + [errorDecl, cCallStmt] + errorCheck + releaseStmts + returnStmt } var lines: [String] = [] @@ -800,9 +1175,17 @@ private func renderThrowingBody(_ plan: CallablePlan, indent: String) -> [String lines.append("\(scope)return try \(sp.swiftName).withCString { \(sp.cName) in") scope += " " } + for stmt in setupStmts { + let stripped = stmt.hasPrefix(indent) ? String(stmt.dropFirst(indent.count)) : stmt + lines.append("\(scope)\(stripped)") + } lines.append("\(scope)\(errorDecl)") lines.append("\(scope)\(cCallStmt)") lines += errorCheck.map { $0.hasPrefix(indent) ? scope + String($0.dropFirst(indent.count)) : $0 } + for stmt in releaseStmts { + let stripped = stmt.hasPrefix(indent) ? String(stmt.dropFirst(indent.count)) : stmt + lines.append("\(scope)\(stripped)") + } lines += returnStmt.map { $0.hasPrefix(indent) ? scope + String($0.dropFirst(indent.count)) : $0 } for _ in stringParams { scope = String(scope.dropLast(4)) @@ -953,6 +1336,11 @@ private func marshalCallArg(_ param: ParameterPlan) -> String { return pointerArg(param) case .boxedPointer: return pointerArg(param) + case .callbackBox(let scope, _): + // The callback itself is passed as the C arg (Swift closures with + // @convention(c) convert to C function pointers automatically). + // The opaque data pointer goes to the user-data slot via closureDataMap. + return param.swiftName case .unsupported(let reason): return "/* unsupported: \(reason) */" } diff --git a/Sources/SwiftGtkGenCore/Planner.swift b/Sources/SwiftGtkGenCore/Planner.swift index fa50180..45d9501 100644 --- a/Sources/SwiftGtkGenCore/Planner.swift +++ b/Sources/SwiftGtkGenCore/Planner.swift @@ -1,3 +1,15 @@ +// Phase D7 (per-signature scope=notified destroy trampolines): DEFERRED. +// Verified zero scope="notified" callback params flow through the plan +// layer in tier 1 (GLib + GObject). All notified scopes are on +// g_signal_connect_data (shortcircuited by the @_silgen_name shim in +// renderSupport) or on callables whose callback params are skipped with +// .callbackWithoutUserData until D4.3 lands. Deferral is plan-sanctioned +// per local://phase-d-signals-callbacks-plan.md §D7 contingency. +// When a tier-1 callable with a notified callback param surfaces, +// renderCallable's callback-box branch must populate +// destroyTrampoline="" and emit a per-signature +// @_cdecl destroy trampoline. + // Planner.swift // The binding planner: walks a parsed GIR namespace, resolves every type // through the registry and TypeMapper, and produces either a complete @@ -51,7 +63,10 @@ private func planNamespace(_ ns: Namespace, context: MapContext) -> ModulePlan { var totalTypes = 0 var boundCallables = 0 var totalCallables = 0 - + var boundCallbacks = 0 + var totalCallbacks = 0 + var boundSignals = 0 + var totalSignals = 0 // ── Enumerations ── for enumeration in ns.enumerations { totalTypes += 1; boundTypes += planEnum(into: &types, skips: &skips, enumeration: enumeration, context: context) @@ -77,22 +92,25 @@ private func planNamespace(_ ns: Namespace, context: MapContext) -> ModulePlan { for alias in ns.aliases { totalTypes += 1; boundTypes += planAliasType(into: &types, skips: &skips, alias: alias, context: context) } - - // ── Classes, Interfaces, Records, Callbacks — skip with reasons (Phase B6+) ── for klass in ns.classes { totalTypes += 1 boundTypes += skipClass(into: &skips, into: &types, boundCallables: &boundCallables, totalCallables: &totalCallables, klass: klass, namespace: ns.name, context: context) + if case .class(let cp) = types.last { totalSignals += klass.signals.filter(\.symbolInfo.isBindable).count; boundSignals += cp.signals.count } } for iface in ns.interfaces { totalTypes += 1; boundTypes += skipInterface(into: &skips, into: &types, iface: iface, namespace: ns.name, context: context) + if case .interface(let ip) = types.last { totalSignals += iface.signals.filter(\.symbolInfo.isBindable).count; boundSignals += ip.signals.count } } for record in ns.records { totalTypes += 1; boundTypes += skipRecord(into: &skips, into: &types, record: record, namespace: ns.name, context: context) } for callback in ns.callbacks { - totalTypes += 1; boundTypes += skipCallback(into: &skips, callback: callback, namespace: ns.name) + totalCallbacks += 1 + totalTypes += 1; boundTypes += planCallbackType(into: &skips, into: &types, + callback: callback, namespace: ns.name, context: context) + if case .callback(_) = types.last { boundCallbacks += 1 } } for fn in ns.functions { totalCallables += 1 @@ -166,7 +184,9 @@ private func planNamespace(_ ns: Namespace, context: MapContext) -> ModulePlan { let coverage = CoverageStats( boundCallables: boundCallables, totalCallables: totalCallables, - boundTypes: boundTypes, totalTypes: totalTypes + boundTypes: boundTypes, totalTypes: totalTypes, + boundCallbacks: boundCallbacks, totalCallbacks: totalCallbacks, + boundSignals: boundSignals, totalSignals: totalSignals ) return ModulePlan(module: context.currentModule, types: types, skips: skips, coverage: coverage) @@ -379,11 +399,41 @@ private func skipRecord(into skips: inout [SkipEntry], into types: inout [TypePl return 0 } -private func skipCallback(into skips: inout [SkipEntry], callback: Callback, namespace: String) -> Int { +/// Plans a namespace-level callback as a `CallbackTypePlan`. +/// +/// Tries to map every parameter and return value through the TypeMapper. +/// On success, produces a `.callback(CallbackTypePlan)` type plan. +/// On failure (unmappable param/return), emits a `SkipEntry` with the +/// existing `.callbackWithoutUserData` reason and a detail explaining why. +/// - Returns: 1 when the callback was bound, 0 when skipped. +private func planCallbackType(into skips: inout [SkipEntry], into types: inout [TypePlan], + callback: Callback, namespace: String, context: MapContext) -> Int { let fullName = "\(namespace).\(callback.name)" - skips.append(SkipEntry(symbol: fullName, cIdentifier: callback.cType, - reason: .callbackWithoutUserData, detail: "callback planned for Phase D2")) - return 0 + // Map the callback through the TypeMapper — this recursively maps + // every parameter and return value. If any fails, we skip with the + // existing callbackWithoutUserData reason (baseline-stable). + let refType = GIRType.typeRef(callback.name, namespace: namespace) + do { + let mapping = try map(refType, nullable: false, transfer: .none, context: context) + let plan = CallbackTypePlan( + name: callback.name, + swiftType: mapping.swiftType, + cSwiftType: mapping.cSwiftType, + doc: callback.doc + ) + types.append(.callback(plan)) + return 1 + } catch let error as MapError { + skips.append(SkipEntry(symbol: fullName, cIdentifier: callback.cType, + reason: error.reason == .callbackWithoutUserData ? .callbackWithoutUserData : error.reason, + detail: "callback '\(callback.name)' has unmappable param/return: \(error.detail)")) + return 0 + } catch { + skips.append(SkipEntry(symbol: fullName, cIdentifier: callback.cType, + reason: .callbackWithoutUserData, + detail: "callback '\(callback.name)' unmappable")) + return 0 + } } /// Plans a namespace-level function, appending a `.callable` type plan on @@ -391,6 +441,12 @@ private func skipCallback(into skips: inout [SkipEntry], callback: Callback, nam private func planOrSkipFunction(into skips: inout [SkipEntry], into types: inout [TypePlan], fn: GlobalFunction, namespace: String, context: MapContext) -> Int { let fullName = "\(namespace).\(fn.name)" + // Check bindability: introspectable, not shadowed, not deprecated-removed + if let skipEntry = checkBindable(fn.symbolInfo, fullName: fullName, cIdentifier: fn.cIdentifier) { + skips.append(skipEntry) + return 0 + } + // Symbols the system library does not export (macros, inline functions, // or GType getters absent from the shared object) cannot be called. if knownMissingCFunctions.contains(fn.cIdentifier) { @@ -567,6 +623,17 @@ func planInterface(_ iface: Interface, context: MapContext) -> (plan: InterfaceP } } + // ── Signals ── + var signalPlans: [SignalPlan] = [] + for signal in iface.signals where signal.symbolInfo.isBindable { + let result = planSignal(signal, onClass: iface.name, namespace: context.currentNamespace, context: context) + if let plan = result.plan { + signalPlans.append(plan) + } else if let skip = result.skip { + memberSkips.append(skip) + } + } + // Compute the module-qualified name for matching ClassPlan.interfaces. let qualifiedName: String = { let girName = "\(context.currentNamespace).\(iface.name)" @@ -575,13 +642,13 @@ func planInterface(_ iface: Interface, context: MapContext) -> (plan: InterfaceP } return registry.swiftTypeName(for: resolved, in: context.currentModule) }() - let plan = InterfacePlan( name: iface.name, cType: iface.cType, prereqs: prereqSwiftNames, getTypeFunction: iface.getTypeFunction, methods: methodPlans, properties: propertyPlans, + signals: signalPlans, qualifiedName: qualifiedName, doc: iface.doc ) @@ -780,6 +847,17 @@ func planClass(_ klass: Class, context: MapContext) -> (plan: ClassPlan, memberS } } + // ── Signals ── + var signalPlans: [SignalPlan] = [] + for signal in klass.signals where signal.symbolInfo.isBindable { + let result = planSignal(signal, onClass: klass.name, namespace: context.currentNamespace, context: context) + if let plan = result.plan { + signalPlans.append(plan) + } else if let skip = result.skip { + memberSkips.append(skip) + } + } + let plan = ClassPlan( name: klass.name, cType: klass.cType, parent: parentSwiftName, @@ -792,6 +870,7 @@ func planClass(_ klass: Class, context: MapContext) -> (plan: ClassPlan, memberS methods: methodPlans, functions: functionPlans, properties: propertyPlans, + signals: signalPlans, doc: klass.doc ) return (plan, memberSkips) @@ -937,6 +1016,13 @@ private func planCallable( return .skip(SkipEntry(symbol: fullName, cIdentifier: cIdentifier, reason: .unknownType, detail: "return type: \(reason)")) } + // Callback return types cannot be constructed from C function + // pointers yet — the renderer has no marshal-out support. + if returnMap.category == .callback { + return .skip(SkipEntry(symbol: fullName, cIdentifier: cIdentifier, + reason: .callbackWithoutUserData, + detail: "callback return type '\(returnMap.swiftType)' deferred")) + } returnMapping = returnMap case .failure(let error as MapError): return .skip(SkipEntry(symbol: fullName, cIdentifier: cIdentifier, @@ -974,6 +1060,101 @@ func planMethod(_ method: Method, context: MapContext) -> CallablePlanResult { throwsGError: method.throwsGError, doc: method.doc, isStatic: false, context: context) } +/// Plans a GObject signal for a class or interface. +/// +/// Maps every signal parameter and the return value through the TypeMapper. +/// The implicit instance parameter (C-arg 0) is synthesized using the owning +/// class's type. Returns a ``SignalPlan`` on success or a skip entry on +/// failure (e.g. unmappable parameter type). +/// +/// - Parameters: +/// - signal: The signal to plan. +/// - className: The owning class/interface Swift name. +/// - namespace: The GIR namespace name. +/// - context: The resolution context. +/// - Returns: A tuple of optional plan and optional skip entry (exactly one is non-nil). +private func planSignal(_ signal: Signal, onClass className: String, + namespace: String, context: MapContext) -> (plan: SignalPlan?, skip: SkipEntry?) { + let girName = "\(context.currentNamespace).\(className).\(signal.name)" + + var signalParams: [ParameterPlan] = [] + + // Instance parameter: C-arg 0, the emitting GObject pointer. + // Its Swift type is the owning class; its C type is UnsafeMutableRawPointer. + let instanceParam = ParameterPlan( + swiftName: "instance", cArgIndex: 0, + mapping: Mapping(swiftType: className, cSwiftType: "UnsafeMutableRawPointer", + marshalIn: .direct, marshalOut: .direct), + isInstanceParameter: true + ) + signalParams.append(instanceParam) + + // Map each real signal parameter + for (idx, param) in signal.parameters.enumerated() { + do { + let mapping = try map(param.type, nullable: param.isNullable, + transfer: param.transferOwnership, context: context) + guard mapping.isReadyForCallables else { + return (nil, SkipEntry(symbol: girName, cIdentifier: nil, + reason: .signalUnmappableParam, + detail: "param '\(param.name)' type '\(mapping.swiftType)' not ready for callables")) + } + let pName = swiftParameterName(param.name) + signalParams.append(ParameterPlan( + swiftName: pName, cArgIndex: idx + 1, // +1 because instance param is index 0 + mapping: mapping + )) + } catch let error as MapError { + return (nil, SkipEntry(symbol: girName, cIdentifier: nil, + reason: .signalUnmappableParam, + detail: "param '\(param.name)': \(error.detail)")) + } catch { + return (nil, SkipEntry(symbol: girName, cIdentifier: nil, + reason: .signalUnmappableParam, + detail: "param '\(param.name)': unexpected error")) + } + } + + // Map return value + let returnMapping: Mapping? + if signal.returnValue.type != .void { + do { + let mapped = try map(signal.returnValue.type, nullable: signal.returnValue.isNullable, + transfer: signal.returnValue.transferOwnership, context: context) + guard mapped.isReadyForCallables else { + return (nil, SkipEntry(symbol: girName, cIdentifier: nil, + reason: .signalUnmappableParam, + detail: "return type '\(mapped.swiftType)' not ready for callables")) + } + returnMapping = mapped + } catch let error as MapError { + return (nil, SkipEntry(symbol: girName, cIdentifier: nil, + reason: .signalUnmappableParam, + detail: "return: \(error.detail)")) + } catch { + return (nil, SkipEntry(symbol: girName, cIdentifier: nil, + reason: .signalUnmappableParam, + detail: "return: unexpected error")) + } + } else { + returnMapping = nil + } + + let swiftName = swiftFunctionName(signal.name) + let trampolineCName = "_trampoline_\(namespace)_\(className)_\(signal.name)" + + let plan = SignalPlan( + owningClassName: className, girName: signal.name, + swiftName: swiftName, + isDetailed: signal.isDetailed, + parameters: signalParams, + returnMapping: returnMapping, + trampolineCName: trampolineCName, + doc: signal.doc + ) + return (plan, nil) +} + /// Plans a constructor as a Swift `convenience init`. The C constructor's /// returned instance pointer is adopted through the class's designated /// `init(takingOwnership:)`, which sinks a floating reference when the class @@ -1018,7 +1199,10 @@ func planParameters( _ parameters: [Parameter], context: MapContext ) -> ParameterPlanResult { var plans: [ParameterPlan] = [] - + // Pre-scan: collect indices that are user-data targets for callbacks. + // These are plain gpointer params that would otherwise fail the pointer + // check — the callback-box mechanism handles them. + let closureTargets = Set(parameters.compactMap(\.closureIndex)) for (index, param) in parameters.enumerated() { // The instance parameter is always `self` — passed as `self.pointer`, // never type-checked (its type is the enclosing class, which is a @@ -1099,11 +1283,16 @@ func planParameters( let mappingResult = Result { try map(param.type, nullable: param.isNullable, transfer: param.transferOwnership, context: context) } switch mappingResult { - case .success(let paramMapping): - if !paramMapping.isReadyForCallables { + case .success(var paramMapping): + // D4.3 callback-param binding remains deferred: passing a Swift + // closure captured as `@convention(c)` through generic + // `_ClosureBox` storage triggers a Swift compiler ICE + // ("failed to produce diagnostic for expression") on functions + // like `g_qsort_with_data`/`g_dataset_foreach`. See HANDOFF.md. + if case .callbackBox = paramMapping.marshalIn { return .skip(SkipEntry(symbol: "", cIdentifier: nil, - reason: .unknownType, - detail: "parameter '\(param.name)' type '\(paramMapping.swiftType)' is not yet generated")) + reason: .callbackWithoutUserData, + detail: "callback param '\(param.name)' deferred to Phase D4.3")) } let isString = paramMapping.marshalIn == .stringToC @@ -1125,19 +1314,22 @@ func planParameters( } } // Non-string pointer parameters that aren't mapped as objects or - // boxed records need address-of / wrapper marshalling — deferred. - // Object and boxed params have their own marshalIn paths (.objectPointer, - // .boxedPointer) that pass the wrapper's pointer. if param.cType.hasSuffix("*") && !isString, - paramMapping.category != .needsClass, paramMapping.category != .needsRecord { + paramMapping.category != .needsClass, paramMapping.category != .needsRecord, + !closureTargets.contains(index) { return .skip(SkipEntry(symbol: "", cIdentifier: nil, reason: .unknownType, detail: "parameter '\(param.name)' C type '\(param.cType)' is a pointer")) } let swiftName = swiftParameterName(param.name) + // Only record a separate closureIndex when it differs from the + // callback param's own C arg index (callback doubling as user-data + // is the common case and needs no replacement). + let planClosure: Int? = (param.closureIndex != index) ? param.closureIndex : nil plans.append(ParameterPlan( swiftName: swiftName, cArgIndex: index, - mapping: paramMapping, isInstanceParameter: param.isInstanceParameter + mapping: paramMapping, isInstanceParameter: param.isInstanceParameter, + closureIndex: planClosure, destroyIndex: param.destroyIndex )) case .failure(let error as MapError): return .skip(SkipEntry(symbol: "", cIdentifier: nil, diff --git a/Sources/SwiftGtkGenCore/TypeMapper.swift b/Sources/SwiftGtkGenCore/TypeMapper.swift index 0a3446f..0553094 100644 --- a/Sources/SwiftGtkGenCore/TypeMapper.swift +++ b/Sources/SwiftGtkGenCore/TypeMapper.swift @@ -74,7 +74,7 @@ public struct Mapping: Equatable, Sendable { /// boxed records need their wrapper class. Once generated, callables /// referencing these types can be planned. public var isReadyForCallables: Bool { - category == .ready || category == .needsClass || category == .needsRecord + category == .ready || category == .needsClass || category == .needsRecord || category == .callback } } @@ -302,8 +302,63 @@ private func mapTypeRef( detail: "'\(namespace).\(name)' has no GType registration or lifetime functions") case .callback: - throw MapError(reason: .callbackWithoutUserData, - detail: "callback '\(namespace).\(name)' not yet supported as a mapped type") + let girName = "\(namespace).\(name)" + guard let cb = context.registry.callback(girName: girName) else { + throw MapError(reason: .unknownType, + detail: "callback '\(girName)' not found in registry") + } + // Split real parameters from the trailing user-data pointer + let userDataIdx = cb.userDataParameterIndex + let realParams: [Parameter] + if let idx = userDataIdx { + realParams = Array(cb.parameters[.. Callback? { + callbacks[girName] + } + /// The namespaces referenced via `` but not generated, plus any /// namespaces excluded by configuration. /// diff --git a/Tests/SwiftGtkGenCoreTests/CallbackGenerationTests.swift b/Tests/SwiftGtkGenCoreTests/CallbackGenerationTests.swift new file mode 100644 index 0000000..239cfb2 --- /dev/null +++ b/Tests/SwiftGtkGenCoreTests/CallbackGenerationTests.swift @@ -0,0 +1,167 @@ +// CallbackGenerationTests.swift +// Covers Phase D6/D4.3: namespace-level callback typealias emission and +// callback-typed parameter marshalling. +// +// D4.3 status: the planner (`Planner.planParameters`) still blanket-skips +// every callback-typed parameter with `.callbackWithoutUserData` — real +// binding is blocked by a Swift compiler ICE ("failed to produce diagnostic +// for expression") triggered when a `@convention(c)` closure boxed in the +// generic `_ClosureBox` is passed to a C function expecting a distinct +// `@convention(c)` typealias (reproduced on `g_qsort_with_data`). See +// `Planner.swift`'s D4.3 comment and HANDOFF.md. The renderer-side +// infrastructure (`marshalCallArg`'s `.callbackBox` branch, `callbackBoxSetup` +// / `callbackBoxRelease`) is implemented and exercised here by constructing +// `CallablePlan` values directly — bypassing the planner — so the renderer +// logic is proven correct independent of the planner's current skip. + +import Testing + +@testable import SwiftGtkGenCore + +@Suite("Callback generation") +struct CallbackGenerationTests { + func makeContext() -> MapContext { + let glib = Repository(namespaces: [ + Namespace(name: "GLib", version: "2.0", + callbacks: [Callback(name: "CompareDataFunc", cType: "GCompareDataFunc")]) + ]) + let registry = TypeRegistry(repositories: ["GLib": glib]) + return MapContext(registry: registry, currentModule: "GLib", currentNamespace: "GLib") + } + + // MARK: - Typealias emission (D6) + + @Test("renderCallbackType emits both the @convention(c) form and the Swift-closure form") + func callbackTypeEmitsBothTypealiases() throws { + let plan = CallbackTypePlan( + name: "CompareFunc", + swiftType: "(UnsafeRawPointer?, UnsafeRawPointer?) -> Int32", + cSwiftType: "@convention(c) (UnsafeRawPointer?, UnsafeRawPointer?) -> Int32" + ) + let module = ModulePlan(module: "GLib", types: [.callback(plan)], skips: [], + coverage: CoverageStats()) + let files = renderModule(module) + let source = files["Callbacks.swift"] ?? "" + #expect(source.contains("public typealias CompareFunc = @convention(c) (UnsafeRawPointer?, UnsafeRawPointer?) -> Int32")) + #expect(source.contains("public typealias CompareFuncSwift = (UnsafeRawPointer?, UnsafeRawPointer?) -> Int32")) + } + + // MARK: - Planner baseline (unchanged pending D4.3) + + @Test("A callback-typed parameter still skips with callbackWithoutUserData (D4.3 deferred)") + func callbackParamStillSkipped() throws { + let fn = GlobalFunction( + name: "qsort_with_data", cIdentifier: "g_qsort_with_data", + parameters: [ + Parameter(name: "compare_func", type: .typeRef("CompareDataFunc", namespace: "GLib"), + cType: "GCompareDataFunc"), + ] + ) + guard case .skip(let entry) = planFunction(fn, context: makeContext()) else { + Issue.record("expected callback-typed param to still skip pending D4.3"); return + } + #expect(entry.reason == .callbackWithoutUserData) + } + + // MARK: - Renderer infrastructure (constructed directly — D4.3 render-side proof) + + /// A `.callbackBox(scope: .call, …)` parameter that doubles as its own + /// user-data slot (`closureIndex == cArgIndex`, GLib's common + /// `..._with_data` pattern) — mirrors the shape `g_qsort_with_data` would + /// plan to once D4.3's planner-side ICE is resolved. + var scopeCallCallable: CallablePlan { + let callbackMapping = Mapping( + swiftType: "(UnsafeRawPointer?, UnsafeRawPointer?, UnsafeMutableRawPointer?) -> Int32", + cSwiftType: "@convention(c) (UnsafeRawPointer?, UnsafeRawPointer?, UnsafeMutableRawPointer?) -> Int32", + marshalIn: .callbackBox(scope: .call, destroyTrampoline: ""), + marshalOut: .direct, + category: .callback + ) + let param = ParameterPlan( + swiftName: "compareFunc", cArgIndex: 0, + mapping: callbackMapping, closureIndex: 0 + ) + return CallablePlan(name: "qsortWithData", cIdentifier: "g_qsort_with_data", parameters: [param]) + } + + @Test("A scope=.call callback param has no separate user-data ParameterPlan when closureIndex == cArgIndex") + func scopeCallHasNoSeparateUserData() throws { + let plan = scopeCallCallable + #expect(plan.parameters.count == 1) + let param = plan.parameters[0] + guard case .callbackBox(let scope, let destroyTrampoline) = param.mapping.marshalIn else { + Issue.record("expected .callbackBox marshalIn"); return + } + #expect(scope == .call) + #expect(destroyTrampoline == "") + #expect(param.closureIndex == param.cArgIndex) + } + + @Test("renderCallable for a scope=.call callback emits box setup before the C call and release after") + func scopeCallEmitsSetupAndRelease() throws { + let module = ModulePlan(module: "GLib", types: [.callable(scopeCallCallable)], skips: [], + coverage: CoverageStats()) + let files = renderModule(module) + let source = files["Functions.swift"] ?? "" + + // Setup: box the closure and take an opaque retained pointer BEFORE + // the C call. + #expect(source.contains("_ClosureBox(compareFunc)")) + #expect(source.contains("Unmanaged.passRetained")) + #expect(source.contains("g_qsort_with_data(")) + + // Release: scope=.call takes the closure back and releases it AFTER + // the C call returns (matches gtk-rs stack-borrow lifetime) — the box + // must not leak. + #expect(source.contains("takeRetainedValue()")) + + // Ordering: the setup line must appear before the C call line, and + // the release line after it. + let setupIdx = source.range(of: "Unmanaged.passRetained")!.lowerBound + let callIdx = source.range(of: "g_qsort_with_data(")!.lowerBound + let releaseIdx = source.range(of: "takeRetainedValue()")!.lowerBound + #expect(setupIdx < callIdx) + #expect(callIdx < releaseIdx) + } + + @Test("Support.swift emits the closure-box runtime when a module has callback-param callables but no signals") + func supportEmitsClosureBoxForCallbacksWithoutSignals() throws { + let module = ModulePlan(module: "GLib", types: [.callable(scopeCallCallable)], skips: [], + coverage: CoverageStats()) + let files = renderModule(module) + let support = files["Support.swift"] ?? "" + #expect(support.contains("_ClosureBox")) + } + + // MARK: - CoverageStats (R7 / D8) + + @Test("CoverageStats tallies bound callbacks and signals from a fixture namespace") + func coverageStatsCountsCallbacksAndSignals() throws { + let ns = Namespace( + name: "GLib", version: "2.0", + classes: [ + Class(name: "Emitter", cType: "GEmitter", parent: nil, + getTypeFunction: "g_emitter_get_type", + signals: [Signal(name: "fired", isDetailed: false)]), + ], + callbacks: [ + Callback(name: "SimpleCallback", cType: "GSimpleCallback"), + ] + ) + let repo = Repository(namespaces: [ns]) + let analysis = MultiPackageAnalysis( + repositories: ["GLib": repo], + directDependencies: ["GLib": []], + transitiveDependencies: ["GLib": []], + implicitImports: ["GLib": []], + packageConfigs: [:] + ) + let registry = TypeRegistry(repositories: ["GLib": repo]) + let module = planModules(analysis: analysis, registry: registry)["GLib"] + let coverage = module?.coverage ?? CoverageStats() + #expect(coverage.boundCallbacks == 1) + #expect(coverage.totalCallbacks == 1) + #expect(coverage.boundSignals == 1) + #expect(coverage.totalSignals == 1) + } +} diff --git a/Tests/SwiftGtkGenCoreTests/InterfaceSignalGenerationTests.swift b/Tests/SwiftGtkGenCoreTests/InterfaceSignalGenerationTests.swift new file mode 100644 index 0000000..5db518e --- /dev/null +++ b/Tests/SwiftGtkGenCoreTests/InterfaceSignalGenerationTests.swift @@ -0,0 +1,78 @@ +// InterfaceSignalGenerationTests.swift +// Covers Phase D4.2: GObject interface signals. Tier 1 (GLib + GObject) has +// zero interface signals at runtime — every tier-1 signal lives on a class +// (`Object`, `BindingGroup`) — so the compile gate and smoke tests cannot +// exercise this path. This unit test is the only proof that +// `renderInterface` actually emits a signal extension + trampoline instead +// of silently dropping `InterfacePlan.signals` (the D4.2 regression this +// suite guards against). + +import Testing + +@testable import SwiftGtkGenCore + +@Suite("Interface signal generation") +struct InterfaceSignalGenerationTests { + func makeContext() -> MapContext { + let gobject = Repository(namespaces: [ + Namespace( + name: "GObject", version: "2.0", + classes: [ + Class(name: "Object", cType: "GObject", parent: nil, + getTypeFunction: "g_object_get_type"), + ] + ) + ]) + let registry = TypeRegistry(repositories: ["GObject": gobject]) + return MapContext(registry: registry, currentModule: "GObject", currentNamespace: "GObject") + } + + /// Plans a one-off interface carrying `signals` and renders it, returning + /// the interface file body plus the plan and member skips. + func renderInterfaceFile(named name: String, signals: [Signal]) -> (source: String, plan: InterfacePlan, skips: [SkipEntry]) { + let iface = Interface(name: name, cType: "G\(name)", + signals: signals, + getTypeFunction: "g_\(name.lowercased())_get_type") + let (plan, skips) = planInterface(iface, context: makeContext()) + let module = ModulePlan(module: "GObject", types: [.interface(plan)], skips: skips, + coverage: CoverageStats()) + return (renderModule(module)["\(name).swift"] ?? "", plan, skips) + } + + @Test("An interface signal renders a protocol-extension connect method and a file-level trampoline") + func interfaceSignalRendersTrampolineAndConnect() throws { + let clicked = Signal(name: "clicked", isDetailed: false) + let (source, plan, skips) = renderInterfaceFile(named: "Clickable", signals: [clicked]) + #expect(skips.isEmpty) + #expect(plan.signals.count == 1) + + // (a) The protocol declaration is unchanged — still just the + // `pointer` requirement and any methods/properties, no signal noise + // inside the protocol body itself. + #expect(source.contains("public protocol Clickable {")) + #expect(source.contains("var pointer: UnsafeMutableRawPointer { get }")) + + // (b) A protocol extension supplies the connect method as a default + // implementation — signals are not protocol requirements (the C + // signal-emission machinery is identical across all conformers). + #expect(source.contains("extension Clickable {")) + #expect(source.contains("func connectClicked(_ handler:")) + + // (c) A file-level @_cdecl nonisolated trampoline exists (same + // pattern as class signals) — this is the D4.2 regression check: + // the previous implementation planned interface signals but the + // renderer silently dropped them. + #expect(source.contains("@_cdecl(\"_trampoline_GObject_Clickable_clicked\")")) + #expect(source.contains("nonisolated func _trampoline_GObject_Clickable_clicked(")) + #expect(source.contains("MainActor.assumeIsolated")) + } + + @Test("An interface with no signals renders no extension and no trampoline") + func interfaceWithoutSignalsOmitsExtension() throws { + let (source, plan, skips) = renderInterfaceFile(named: "Plain", signals: []) + #expect(skips.isEmpty) + #expect(plan.signals.isEmpty) + #expect(!source.contains("extension Plain {")) + #expect(!source.contains("@_cdecl")) + } +} diff --git a/Tests/SwiftGtkGenCoreTests/SignalGenerationTests.swift b/Tests/SwiftGtkGenCoreTests/SignalGenerationTests.swift new file mode 100644 index 0000000..6207cfa --- /dev/null +++ b/Tests/SwiftGtkGenCoreTests/SignalGenerationTests.swift @@ -0,0 +1,105 @@ +// SignalGenerationTests.swift +// Covers Phase D signal generation: `@_cdecl nonisolated` trampolines that +// hop to `MainActor.assumeIsolated` before constructing typed wrappers and +// invoking the user's closure, plus the `connect` method that boxes the +// closure, wires the ABI-correct 2-arg `GClosureNotify` destroy callback into +// `g_signal_connect_data`, and returns a `SignalHandle`. + +import Testing + +@testable import SwiftGtkGenCore + +@Suite("Signal generation") +struct SignalGenerationTests { + /// A GObject-local context registering a root `Object` class — the + /// minimal registry needed to plan a signal whose instance param resolves + /// to a known class. + func makeContext() -> MapContext { + let gobject = Repository(namespaces: [ + Namespace( + name: "GObject", version: "2.0", + classes: [ + Class(name: "Object", cType: "GObject", parent: nil, + getTypeFunction: "g_object_get_type"), + Class(name: "ParamSpec", cType: "GParamSpec", parent: nil, + getTypeFunction: "g_param_spec_get_type"), + ] + ) + ]) + let registry = TypeRegistry(repositories: ["GObject": gobject]) + return MapContext(registry: registry, currentModule: "GObject", currentNamespace: "GObject") + } + + /// Plans a one-off class carrying `signals` and renders it, returning the + /// class file body plus the plan and skips. + func renderClass(named name: String, signals: [Signal]) -> (source: String, plan: ClassPlan, skips: [SkipEntry]) { + let klass = Class(name: name, cType: "G\(name)", parent: nil, + getTypeFunction: "g_\(name.lowercased())_get_type", + signals: signals) + let (plan, skips) = planClass(klass, context: makeContext()) + let module = ModulePlan(module: "GObject", types: [.class(plan)], skips: skips, + coverage: CoverageStats()) + return (renderModule(module)["\(name).swift"] ?? "", plan, skips) + } + + @Test("Trampoline emits a @_cdecl nonisolated func with the correct C parameter list") + func trampolineCSignature() throws { + let notify = Signal( + name: "notify", + parameters: [Parameter(name: "pspec", type: .pointer, cType: "GParamSpec*")], + isDetailed: true + ) + let (source, plan, skips) = renderClass(named: "Object", signals: [notify]) + #expect(skips.isEmpty) + #expect(plan.signals.count == 1) + #expect(source.contains("@_cdecl(\"_trampoline_GObject_Object_notify\")")) + #expect(source.contains("nonisolated func _trampoline_GObject_Object_notify(")) + #expect(source.contains("_ instance: UnsafeMutableRawPointer")) + #expect(source.contains("_ data: UnsafeMutableRawPointer?")) + // Body re-enters MainActor before touching the raw pointers. + #expect(source.contains("MainActor.assumeIsolated")) + } + + @Test("isDetailed: true renders a detail parameter; isDetailed: false does not") + func detailedVsNonDetailedSignature() throws { + let detailed = Signal(name: "notify", isDetailed: true) + let bare = Signal(name: "destroy", isDetailed: false) + let (source, plan, skips) = renderClass(named: "Widget", signals: [detailed, bare]) + #expect(skips.isEmpty) + #expect(plan.signals.count == 2) + #expect(source.contains("func connectNotify(detail:")) + #expect(source.contains("func connectDestroy(_ handler:")) + #expect(!source.contains("func connectDestroy(detail:")) + } + + @Test("An unmappable signal parameter type produces a skip, not a partial plan") + func unmappableParamSkip() throws { + // `GIRType.typeRef` to an unregistered type never resolves — the + // planner must skip the whole signal rather than emit a broken plan. + let badSignal = Signal( + name: "weird", + parameters: [Parameter(name: "thing", type: .typeRef("Nonexistent", namespace: "GObject"), + cType: "GNonexistent*")] + ) + let (source, plan, skips) = renderClass(named: "Emitter", signals: [badSignal]) + #expect(plan.signals.isEmpty) + #expect(skips.contains { $0.reason == .signalUnmappableParam }) + #expect(!source.contains("connectWeird")) + } + + @Test("connect method wires the ABI-correct 2-arg destroy callback into g_signal_connect_data") + func destroyNotifyWiring() throws { + let notify = Signal(name: "notify", isDetailed: true) + let (source, _, skips) = renderClass(named: "Object", signals: [notify]) + #expect(skips.isEmpty) + // The destroy closure matches GClosureNotify's 2-arg C signature + // (gpointer data, GClosure *closure) — not GDestroyNotify's 1-arg form. + #expect(source.contains("@convention(c) (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) -> Void")) + #expect(source.contains("_sgtk_destroy_notify_impl(data, nil)")) + // The wired destroy arg is passed (non-nil) to the connect call — + // the D3 leak regression this test guards against. + #expect(source.contains("unsafeBitCast(destroyFn as (@convention(c) (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) -> Void), to: UnsafeRawPointer.self)")) + #expect(source.contains("_sgtk_signal_connect_data(")) + #expect(!source.contains("_sgtk_signal_connect_data(ptr, cName, unsafeBitCast(\\(plan.trampolineCName)")) + } +} diff --git a/docs/skip-baseline/tier1/GLib.json b/docs/skip-baseline/tier1/GLib.json index cf03887..057835f 100644 --- a/docs/skip-baseline/tier1/GLib.json +++ b/docs/skip-baseline/tier1/GLib.json @@ -36,90 +36,24 @@ "reason" : "plainRecord", "symbol" : "GLib.Cache" }, - { - "cIdentifier" : "GCacheDestroyFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CacheDestroyFunc" - }, - { - "cIdentifier" : "GCacheDupFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CacheDupFunc" - }, - { - "cIdentifier" : "GCacheNewFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CacheNewFunc" - }, - { - "cIdentifier" : "GChildWatchFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.ChildWatchFunc" - }, - { - "cIdentifier" : "GClearHandleFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.ClearHandleFunc" - }, - { - "cIdentifier" : "GCompareDataFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CompareDataFunc" - }, - { - "cIdentifier" : "GCompareFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CompareFunc" - }, { "cIdentifier" : "GCompletion", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.Completion" }, - { - "cIdentifier" : "GCompletionFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CompletionFunc" - }, - { - "cIdentifier" : "GCompletionStrncmpFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CompletionStrncmpFunc" - }, { "cIdentifier" : "GCond", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.Cond" }, - { - "cIdentifier" : "GCopyFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.CopyFunc" - }, { "cIdentifier" : "GData", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.Data" }, - { - "cIdentifier" : "GDataForeachFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.DataForeachFunc" - }, { "cIdentifier" : "GDate", "detail" : "record name 'Date' shadows Swift stdlib type", @@ -132,30 +66,6 @@ "reason" : "plainRecord", "symbol" : "GLib.DebugKey" }, - { - "cIdentifier" : "GDestroyNotify", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.DestroyNotify" - }, - { - "cIdentifier" : "GDuplicateFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.DuplicateFunc" - }, - { - "cIdentifier" : "GEqualFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.EqualFunc" - }, - { - "cIdentifier" : "GEqualFuncFull", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.EqualFuncFull" - }, { "cIdentifier" : "GError", "detail" : "record name 'Error' shadows Swift stdlib type", @@ -164,52 +74,22 @@ }, { "cIdentifier" : "GErrorClearFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'ErrorClearFunc' has unmappable param/return: callback 'ErrorClearFunc' param 'error' unmappable: 'GLib.Error' shadows reserved type 'Error'", "reason" : "callbackWithoutUserData", "symbol" : "GLib.ErrorClearFunc" }, { "cIdentifier" : "GErrorCopyFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'ErrorCopyFunc' has unmappable param/return: callback 'ErrorCopyFunc' param 'src_error' unmappable: 'GLib.Error' shadows reserved type 'Error'", "reason" : "callbackWithoutUserData", "symbol" : "GLib.ErrorCopyFunc" }, { "cIdentifier" : "GErrorInitFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'ErrorInitFunc' has unmappable param/return: callback 'ErrorInitFunc' param 'error' unmappable: 'GLib.Error' shadows reserved type 'Error'", "reason" : "callbackWithoutUserData", "symbol" : "GLib.ErrorInitFunc" }, - { - "cIdentifier" : "GFreeFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.FreeFunc" - }, - { - "cIdentifier" : "GFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.Func" - }, - { - "cIdentifier" : "GHFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.HFunc" - }, - { - "cIdentifier" : "GHRFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.HRFunc" - }, - { - "cIdentifier" : "GHashFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.HashFunc" - }, { "cIdentifier" : "GHashTableIter", "detail" : "no GType registration", @@ -222,42 +102,30 @@ "reason" : "plainRecord", "symbol" : "GLib.Hook" }, - { - "cIdentifier" : "GHookCheckFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.HookCheckFunc" - }, { "cIdentifier" : "GHookCheckMarshaller", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'HookCheckMarshaller' has unmappable param/return: callback 'HookCheckMarshaller' param 'hook' unmappable: 'GLib.Hook' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.HookCheckMarshaller" }, { "cIdentifier" : "GHookCompareFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'HookCompareFunc' has unmappable param/return: callback 'HookCompareFunc' param 'new_hook' unmappable: 'GLib.Hook' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.HookCompareFunc" }, { "cIdentifier" : "GHookFinalizeFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'HookFinalizeFunc' has unmappable param/return: callback 'HookFinalizeFunc' param 'hook_list' unmappable: 'GLib.HookList' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.HookFinalizeFunc" }, { "cIdentifier" : "GHookFindFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'HookFindFunc' has unmappable param/return: callback 'HookFindFunc' param 'hook' unmappable: 'GLib.Hook' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.HookFindFunc" }, - { - "cIdentifier" : "GHookFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.HookFunc" - }, { "cIdentifier" : "GHookList", "detail" : "no GType registration", @@ -266,7 +134,7 @@ }, { "cIdentifier" : "GHookMarshaller", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'HookMarshaller' has unmappable param/return: callback 'HookMarshaller' param 'hook' unmappable: 'GLib.Hook' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.HookMarshaller" }, @@ -276,12 +144,6 @@ "reason" : "plainRecord", "symbol" : "GLib.IConv" }, - { - "cIdentifier" : "GIOFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.IOFunc" - }, { "cIdentifier" : "GIOFuncs", "detail" : "no GType registration", @@ -300,15 +162,9 @@ "reason" : "plainRecord", "symbol" : "GLib.LogField" }, - { - "cIdentifier" : "GLogFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.LogFunc" - }, { "cIdentifier" : "GLogWriterFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'LogWriterFunc' has unmappable param/return: callback 'LogWriterFunc' param 'fields' unmappable: C array bridging not yet implemented", "reason" : "callbackWithoutUserData", "symbol" : "GLib.LogWriterFunc" }, @@ -338,13 +194,13 @@ }, { "cIdentifier" : "GNodeForeachFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'NodeForeachFunc' has unmappable param/return: callback 'NodeForeachFunc' param 'node' unmappable: 'GLib.Node' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.NodeForeachFunc" }, { "cIdentifier" : "GNodeTraverseFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'NodeTraverseFunc' has unmappable param/return: callback 'NodeTraverseFunc' param 'node' unmappable: 'GLib.Node' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.NodeTraverseFunc" }, @@ -354,12 +210,6 @@ "reason" : "plainRecord", "symbol" : "GLib.Once" }, - { - "cIdentifier" : "GOptionArgFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.OptionArgFunc" - }, { "cIdentifier" : "GOptionContext", "detail" : "no GType registration", @@ -374,13 +224,13 @@ }, { "cIdentifier" : "GOptionErrorFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'OptionErrorFunc' has unmappable param/return: callback 'OptionErrorFunc' param 'context' unmappable: 'GLib.OptionContext' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.OptionErrorFunc" }, { "cIdentifier" : "GOptionParseFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'OptionParseFunc' has unmappable param/return: callback 'OptionParseFunc' param 'context' unmappable: 'GLib.OptionContext' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.OptionParseFunc" }, @@ -390,18 +240,6 @@ "reason" : "plainRecord", "symbol" : "GLib.PathBuf" }, - { - "cIdentifier" : "GPollFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.PollFunc" - }, - { - "cIdentifier" : "GPrintFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.PrintFunc" - }, { "cIdentifier" : "GPrivate", "detail" : "no GType registration", @@ -434,7 +272,7 @@ }, { "cIdentifier" : "GRegexEvalCallback", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'RegexEvalCallback' has unmappable param/return: callback 'RegexEvalCallback' param 'result' unmappable: 'GLib.String' shadows reserved type 'String'", "reason" : "callbackWithoutUserData", "symbol" : "GLib.RegexEvalCallback" }, @@ -450,12 +288,6 @@ "reason" : "plainRecord", "symbol" : "GLib.SList" }, - { - "cIdentifier" : "SOURCE_REMOVE", - "detail" : "Swift name 'sourceRemove' conflicts with a function in this module", - "reason" : "nameCollision", - "symbol" : "GLib.SOURCE_REMOVE" - }, { "cIdentifier" : "GScanner", "detail" : "no GType registration", @@ -470,7 +302,7 @@ }, { "cIdentifier" : "GScannerMsgFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'ScannerMsgFunc' has unmappable param/return: callback 'ScannerMsgFunc' param 'scanner' unmappable: 'GLib.Scanner' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.ScannerMsgFunc" }, @@ -488,7 +320,7 @@ }, { "cIdentifier" : "GSequenceIterCompareFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'SequenceIterCompareFunc' has unmappable param/return: callback 'SequenceIterCompareFunc' param 'a' unmappable: 'GLib.SequenceIter' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.SequenceIterCompareFunc" }, @@ -498,72 +330,18 @@ "reason" : "plainRecord", "symbol" : "GLib.SourceCallbackFuncs" }, - { - "cIdentifier" : "GSourceDisposeFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceDisposeFunc" - }, - { - "cIdentifier" : "GSourceDummyMarshal", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceDummyMarshal" - }, - { - "cIdentifier" : "GSourceFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceFunc" - }, { "cIdentifier" : "GSourceFuncs", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.SourceFuncs" }, - { - "cIdentifier" : "GSourceFuncsCheckFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceFuncsCheckFunc" - }, - { - "cIdentifier" : "GSourceFuncsDispatchFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceFuncsDispatchFunc" - }, - { - "cIdentifier" : "GSourceFuncsFinalizeFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceFuncsFinalizeFunc" - }, - { - "cIdentifier" : "GSourceFuncsPrepareFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceFuncsPrepareFunc" - }, - { - "cIdentifier" : "GSourceOnceFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SourceOnceFunc" - }, { "cIdentifier" : "GSourcePrivate", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.SourcePrivate" }, - { - "cIdentifier" : "GSpawnChildSetupFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.SpawnChildSetupFunc" - }, { "cIdentifier" : "GStatBuf", "detail" : "no GType registration", @@ -618,36 +396,12 @@ "reason" : "plainRecord", "symbol" : "GLib.TestConfig" }, - { - "cIdentifier" : "GTestDataFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.TestDataFunc" - }, - { - "cIdentifier" : "GTestFixtureFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.TestFixtureFunc" - }, - { - "cIdentifier" : "GTestFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.TestFunc" - }, { "cIdentifier" : "GTestLogBuffer", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.TestLogBuffer" }, - { - "cIdentifier" : "GTestLogFatalFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.TestLogFatalFunc" - }, { "cIdentifier" : "GTestLogMsg", "detail" : "no GType registration", @@ -660,12 +414,6 @@ "reason" : "plainRecord", "symbol" : "GLib.TestSuite" }, - { - "cIdentifier" : "GThreadFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.ThreadFunc" - }, { "cIdentifier" : "GThreadFunctions", "detail" : "no GType registration", @@ -696,27 +444,15 @@ "reason" : "plainRecord", "symbol" : "GLib.Timer" }, - { - "cIdentifier" : "GTranslateFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.TranslateFunc" - }, { "cIdentifier" : "GTrashStack", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GLib.TrashStack" }, - { - "cIdentifier" : "GTraverseFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.TraverseFunc" - }, { "cIdentifier" : "GTraverseNodeFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'TraverseNodeFunc' has unmappable param/return: callback 'TraverseNodeFunc' param 'node' unmappable: 'GLib.TreeNode' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GLib.TraverseNodeFunc" }, @@ -744,12 +480,6 @@ "reason" : "plainRecord", "symbol" : "GLib.VariantIter" }, - { - "cIdentifier" : "GVoidFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GLib.VoidFunc" - }, { "cIdentifier" : "g_access", "detail" : "C symbol 'g_access' is not exported by the system library", @@ -758,14 +488,14 @@ }, { "cIdentifier" : "g_array_new_take", - "detail" : "parameter 'data': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.array_new_take" }, { "cIdentifier" : "g_array_new_take_zero_terminated", - "detail" : "parameter 'data': C array has no length annotation", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.array_new_take_zero_terminated" }, { @@ -782,8 +512,8 @@ }, { "cIdentifier" : "g_assertion_message_cmpnum", - "detail" : "parameter 'arg1': unresolved type 'GLib.long double'", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.assertion_message_cmpnum" }, { @@ -800,25 +530,25 @@ }, { "cIdentifier" : "g_assertion_message_expr", - "detail" : "parameter 'domain' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.assertion_message_expr" }, { "cIdentifier" : "g_async_queue_new", - "detail" : "'GLib.AsyncQueue' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.async_queue_new" }, { "cIdentifier" : "g_async_queue_new_full", - "detail" : "parameter 'item_free_func': callback 'GLib.DestroyNotify' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.async_queue_new_full" }, { "cIdentifier" : "g_atexit", - "detail" : "parameter 'func': callback 'GLib.VoidFunc' not yet supported as a mapped type", + "detail" : "callback param 'func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.atexit" }, @@ -950,7 +680,7 @@ }, { "cIdentifier" : "g_atomic_rc_box_release_full", - "detail" : "parameter 'clear_func': callback 'GLib.DestroyNotify' not yet supported as a mapped type", + "detail" : "callback param 'clear_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.atomic_rc_box_release_full" }, @@ -986,8 +716,8 @@ }, { "cIdentifier" : "g_base64_decode_step", - "detail" : "parameter 'in': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.base64_decode_step" }, { @@ -1038,16 +768,22 @@ "reason" : "unknownType", "symbol" : "GLib.bit_unlock_and_set" }, + { + "cIdentifier" : "g_bookmark_file_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.bookmark_file_error_quark" + }, { "cIdentifier" : "g_build_filename", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.build_filename" }, { "cIdentifier" : "g_build_filename_valist", - "detail" : "parameter 'args': va_list parameters are permanently unbridgeable", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.build_filename_valist" }, { @@ -1058,8 +794,8 @@ }, { "cIdentifier" : "g_build_path", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.build_path" }, { @@ -1070,98 +806,98 @@ }, { "cIdentifier" : "g_byte_array_append", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_append" }, { "cIdentifier" : "g_byte_array_free", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_free" }, { "cIdentifier" : "g_byte_array_free_to_bytes", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_free_to_bytes" }, { "cIdentifier" : "g_byte_array_new", - "detail" : "byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_new" }, { "cIdentifier" : "g_byte_array_new_take", - "detail" : "parameter 'data': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_new_take" }, { "cIdentifier" : "g_byte_array_prepend", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_prepend" }, { "cIdentifier" : "g_byte_array_ref", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_ref" }, { "cIdentifier" : "g_byte_array_remove_index", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_remove_index" }, { "cIdentifier" : "g_byte_array_remove_index_fast", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_remove_index_fast" }, { "cIdentifier" : "g_byte_array_remove_range", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_remove_range" }, { "cIdentifier" : "g_byte_array_set_size", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_set_size" }, { "cIdentifier" : "g_byte_array_sized_new", - "detail" : "byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_sized_new" }, { "cIdentifier" : "g_byte_array_sort", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_sort" }, { "cIdentifier" : "g_byte_array_sort_with_data", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_sort_with_data" }, { "cIdentifier" : "g_byte_array_steal", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_steal" }, { "cIdentifier" : "g_byte_array_unref", - "detail" : "parameter 'array': byteArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.byte_array_unref" }, { @@ -1176,15 +912,21 @@ "reason" : "unknownType", "symbol" : "GLib.chdir" }, + { + "cIdentifier" : "g_checksum_type_get_length", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.checksum_type_get_length" + }, { "cIdentifier" : "g_child_watch_add", - "detail" : "parameter 'function': callback 'GLib.ChildWatchFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "shadowedSymbol", + "reason" : "shadowedSymbol", "symbol" : "GLib.child_watch_add" }, { "cIdentifier" : "g_child_watch_add_full", - "detail" : "parameter 'function': callback 'GLib.ChildWatchFunc' not yet supported as a mapped type", + "detail" : "callback param 'function' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.child_watch_add_full" }, @@ -1196,26 +938,26 @@ }, { "cIdentifier" : "g_clear_handle_id", - "detail" : "parameter 'tag_ptr' C type 'guint*' is a pointer", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.clear_handle_id" }, { "cIdentifier" : "g_clear_list", - "detail" : "parameter 'list_ptr': list container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.clear_list" }, { "cIdentifier" : "g_clear_pointer", - "detail" : "'pp' has direction=inout", - "reason" : "inoutParameter", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.clear_pointer" }, { "cIdentifier" : "g_clear_slist", - "detail" : "parameter 'slist_ptr': slist container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.clear_slist" }, { @@ -1244,8 +986,8 @@ }, { "cIdentifier" : "g_cond_new", - "detail" : "'GLib.Cond' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.cond_new" }, { @@ -1262,8 +1004,8 @@ }, { "cIdentifier" : "g_convert_with_iconv", - "detail" : "parameter 'str': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.convert_with_iconv" }, { @@ -1274,8 +1016,8 @@ }, { "cIdentifier" : "g_datalist_clear", - "detail" : "parameter 'datalist': 'GLib.Data' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.datalist_clear" }, { @@ -1298,8 +1040,8 @@ }, { "cIdentifier" : "g_datalist_id_dup_data", - "detail" : "parameter 'datalist': 'GLib.Data' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.datalist_id_dup_data" }, { @@ -1316,26 +1058,26 @@ }, { "cIdentifier" : "g_datalist_id_remove_no_notify", - "detail" : "parameter 'datalist': 'GLib.Data' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.datalist_id_remove_no_notify" }, { "cIdentifier" : "g_datalist_id_replace_data", - "detail" : "parameter 'datalist': 'GLib.Data' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.datalist_id_replace_data" }, { "cIdentifier" : "g_datalist_id_set_data_full", - "detail" : "parameter 'datalist': 'GLib.Data' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.datalist_id_set_data_full" }, { "cIdentifier" : "g_datalist_init", - "detail" : "parameter 'datalist': 'GLib.Data' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.datalist_init" }, { @@ -1352,22 +1094,94 @@ }, { "cIdentifier" : "g_dataset_foreach", - "detail" : "parameter 'func': callback 'GLib.DataForeachFunc' not yet supported as a mapped type", + "detail" : "callback param 'func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.dataset_foreach" }, + { + "cIdentifier" : "g_dataset_id_remove_no_notify", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", + "symbol" : "GLib.dataset_id_remove_no_notify" + }, { "cIdentifier" : "g_dataset_id_set_data_full", - "detail" : "parameter 'destroy_func': callback 'GLib.DestroyNotify' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.dataset_id_set_data_full" }, + { + "cIdentifier" : "g_date_get_days_in_month", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_get_days_in_month" + }, + { + "cIdentifier" : "g_date_get_monday_weeks_in_year", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_get_monday_weeks_in_year" + }, + { + "cIdentifier" : "g_date_get_sunday_weeks_in_year", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_get_sunday_weeks_in_year" + }, + { + "cIdentifier" : "g_date_get_weeks_in_year", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_get_weeks_in_year" + }, + { + "cIdentifier" : "g_date_is_leap_year", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_is_leap_year" + }, { "cIdentifier" : "g_date_strftime", - "detail" : "parameter 's' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.date_strftime" }, + { + "cIdentifier" : "g_date_valid_day", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_valid_day" + }, + { + "cIdentifier" : "g_date_valid_dmy", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_valid_dmy" + }, + { + "cIdentifier" : "g_date_valid_julian", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_valid_julian" + }, + { + "cIdentifier" : "g_date_valid_month", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_valid_month" + }, + { + "cIdentifier" : "g_date_valid_weekday", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_valid_weekday" + }, + { + "cIdentifier" : "g_date_valid_year", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.date_valid_year" + }, { "cIdentifier" : "g_dcgettext", "detail" : "parameter 'domain' is a nullable string", @@ -1382,8 +1196,8 @@ }, { "cIdentifier" : "g_dir_make_tmp", - "detail" : "parameter 'tmpl' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.dir_make_tmp" }, { @@ -1424,14 +1238,14 @@ }, { "cIdentifier" : "g_error_domain_register", - "detail" : "parameter 'error_type_init': callback 'GLib.ErrorInitFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.error_domain_register" }, { "cIdentifier" : "g_error_domain_register_static", - "detail" : "parameter 'error_type_init': callback 'GLib.ErrorInitFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.error_domain_register_static" }, { @@ -1472,8 +1286,8 @@ }, { "cIdentifier" : "g_fprintf", - "detail" : "parameter 'file' C type 'FILE*' is a pointer", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.fprintf" }, { @@ -1556,218 +1370,218 @@ }, { "cIdentifier" : "g_hash_table_add", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_add" }, { "cIdentifier" : "g_hash_table_contains", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_contains" }, { "cIdentifier" : "g_hash_table_destroy", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_destroy" }, { "cIdentifier" : "g_hash_table_find", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_find" }, { "cIdentifier" : "g_hash_table_foreach", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_foreach" }, { "cIdentifier" : "g_hash_table_foreach_remove", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_foreach_remove" }, { "cIdentifier" : "g_hash_table_foreach_steal", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_foreach_steal" }, { "cIdentifier" : "g_hash_table_get_keys_as_ptr_array", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.hash_table_get_keys_as_ptr_array" }, { "cIdentifier" : "g_hash_table_get_values_as_ptr_array", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.hash_table_get_values_as_ptr_array" }, { "cIdentifier" : "g_hash_table_insert", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_insert" }, { "cIdentifier" : "g_hash_table_lookup", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_lookup" }, { "cIdentifier" : "g_hash_table_lookup_extended", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_lookup_extended" }, { "cIdentifier" : "g_hash_table_new_similar", - "detail" : "parameter 'other_hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_new_similar" }, { "cIdentifier" : "g_hash_table_ref", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_ref" }, { "cIdentifier" : "g_hash_table_remove", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_remove" }, { "cIdentifier" : "g_hash_table_remove_all", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_remove_all" }, { "cIdentifier" : "g_hash_table_replace", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_replace" }, { "cIdentifier" : "g_hash_table_size", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_size" }, { "cIdentifier" : "g_hash_table_steal", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_steal" }, { "cIdentifier" : "g_hash_table_steal_all", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_steal_all" }, { "cIdentifier" : "g_hash_table_steal_all_keys", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.hash_table_steal_all_keys" }, { "cIdentifier" : "g_hash_table_steal_all_values", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.hash_table_steal_all_values" }, { "cIdentifier" : "g_hash_table_steal_extended", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_steal_extended" }, { "cIdentifier" : "g_hash_table_unref", - "detail" : "parameter 'hash_table': hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hash_table_unref" }, { "cIdentifier" : "g_hook_destroy", - "detail" : "parameter 'hook_list': 'GLib.HookList' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hook_destroy" }, { "cIdentifier" : "g_hook_destroy_link", - "detail" : "parameter 'hook_list': 'GLib.HookList' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hook_destroy_link" }, { "cIdentifier" : "g_hook_free", - "detail" : "parameter 'hook_list': 'GLib.HookList' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hook_free" }, { "cIdentifier" : "g_hook_insert_before", - "detail" : "parameter 'hook_list': 'GLib.HookList' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hook_insert_before" }, { "cIdentifier" : "g_hook_insert_sorted", - "detail" : "parameter 'hook_list': 'GLib.HookList' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hook_insert_sorted" }, { "cIdentifier" : "g_hook_prepend", - "detail" : "parameter 'hook_list': 'GLib.HookList' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hook_prepend" }, { "cIdentifier" : "g_hook_unref", - "detail" : "parameter 'hook_list': 'GLib.HookList' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.hook_unref" }, { "cIdentifier" : "g_iconv", - "detail" : "parameter 'converter': 'GLib.IConv' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.iconv" }, { "cIdentifier" : "g_iconv_open", - "detail" : "'GLib.IConv' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.iconv_open" }, { "cIdentifier" : "g_idle_add", - "detail" : "parameter 'function': callback 'GLib.SourceFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "shadowedSymbol", + "reason" : "shadowedSymbol", "symbol" : "GLib.idle_add" }, { "cIdentifier" : "g_idle_add_full", - "detail" : "parameter 'function': callback 'GLib.SourceFunc' not yet supported as a mapped type", + "detail" : "callback param 'function' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.idle_add_full" }, { "cIdentifier" : "g_idle_add_once", - "detail" : "parameter 'function': callback 'GLib.SourceOnceFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.idle_add_once" }, { @@ -1784,20 +1598,44 @@ }, { "cIdentifier" : "g_io_add_watch", - "detail" : "parameter 'func': callback 'GLib.IOFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "shadowedSymbol", + "reason" : "shadowedSymbol", "symbol" : "GLib.io_add_watch" }, { "cIdentifier" : "g_io_add_watch_full", - "detail" : "parameter 'func': callback 'GLib.IOFunc' not yet supported as a mapped type", + "detail" : "callback param 'func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.io_add_watch_full" }, + { + "cIdentifier" : "g_io_channel_error_from_errno", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.io_channel_error_from_errno" + }, + { + "cIdentifier" : "g_io_channel_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.io_channel_error_quark" + }, + { + "cIdentifier" : "g_key_file_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.key_file_error_quark" + }, + { + "cIdentifier" : "g_list_pop_allocator", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.list_pop_allocator" + }, { "cIdentifier" : "g_list_push_allocator", - "detail" : "parameter 'allocator': 'GLib.Allocator' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.list_push_allocator" }, { @@ -1820,8 +1658,8 @@ }, { "cIdentifier" : "g_log", - "detail" : "parameter 'log_domain' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.log" }, { @@ -1832,14 +1670,14 @@ }, { "cIdentifier" : "g_log_set_default_handler", - "detail" : "parameter 'log_func': callback 'GLib.LogFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.log_set_default_handler" }, { "cIdentifier" : "g_log_set_handler", - "detail" : "parameter 'log_domain' is a nullable string", - "reason" : "unknownType", + "detail" : "shadowedSymbol", + "reason" : "shadowedSymbol", "symbol" : "GLib.log_set_handler" }, { @@ -1850,14 +1688,14 @@ }, { "cIdentifier" : "g_log_set_writer_func", - "detail" : "parameter 'func': callback 'GLib.LogWriterFunc' not yet supported as a mapped type", + "detail" : "parameter 'func': callback 'LogWriterFunc' param 'fields' unmappable: C array bridging not yet implemented", "reason" : "callbackWithoutUserData", "symbol" : "GLib.log_set_writer_func" }, { "cIdentifier" : "g_log_structured", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.log_structured" }, { @@ -1868,8 +1706,8 @@ }, { "cIdentifier" : "g_log_structured_standard", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.log_structured_standard" }, { @@ -1922,8 +1760,8 @@ }, { "cIdentifier" : "g_logv", - "detail" : "parameter 'log_domain' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.logv" }, { @@ -1932,24 +1770,48 @@ "reason" : "unknownType", "symbol" : "GLib.lstat" }, + { + "cIdentifier" : "g_main_context_default", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.main_context_default" + }, + { + "cIdentifier" : "g_main_context_get_thread_default", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.main_context_get_thread_default" + }, + { + "cIdentifier" : "g_main_context_ref_thread_default", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.main_context_ref_thread_default" + }, { "cIdentifier" : "g_markup_collect_attributes", - "detail" : "parameter 'attribute_names' is not a single const input string ('const gchar**')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.markup_collect_attributes" }, { "cIdentifier" : "g_markup_printf_escaped", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.markup_printf_escaped" }, { "cIdentifier" : "g_markup_vprintf_escaped", - "detail" : "parameter 'args': va_list parameters are permanently unbridgeable", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.markup_vprintf_escaped" }, + { + "cIdentifier" : "g_mem_chunk_info", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.mem_chunk_info" + }, { "cIdentifier" : "g_mem_set_vtable", "detail" : "parameter 'vtable': 'GLib.MemVTable' has no GType registration or lifetime functions", @@ -1964,38 +1826,44 @@ }, { "cIdentifier" : "g_mkdtemp", - "detail" : "parameter 'tmpl' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.mkdtemp" }, { "cIdentifier" : "g_mkdtemp_full", - "detail" : "parameter 'tmpl' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.mkdtemp_full" }, { "cIdentifier" : "g_mkstemp", - "detail" : "parameter 'tmpl' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.mkstemp" }, { "cIdentifier" : "g_mkstemp_full", - "detail" : "parameter 'tmpl' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.mkstemp_full" }, { "cIdentifier" : "g_mutex_new", - "detail" : "unresolved type 'GLib.Mutex'", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.mutex_new" }, + { + "cIdentifier" : "g_node_pop_allocator", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.node_pop_allocator" + }, { "cIdentifier" : "g_node_push_allocator", - "detail" : "parameter 'allocator': 'GLib.Allocator' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.node_push_allocator" }, { @@ -2012,32 +1880,32 @@ }, { "cIdentifier" : "g_once_init_enter", - "detail" : "'location' has direction=inout", - "reason" : "inoutParameter", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.once_init_enter" }, { "cIdentifier" : "g_once_init_enter_impl", - "detail" : "parameter 'location' C type 'volatile gsize*' is a pointer", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.once_init_enter_impl" }, { "cIdentifier" : "g_once_init_enter_pointer", - "detail" : "parameter 'location' C type 'void*' is a pointer", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.once_init_enter_pointer" }, { "cIdentifier" : "g_once_init_leave", - "detail" : "'location' has direction=inout", - "reason" : "inoutParameter", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.once_init_leave" }, { "cIdentifier" : "g_once_init_leave_pointer", - "detail" : "parameter 'location' C type 'void*' is a pointer", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.once_init_leave_pointer" }, { @@ -2052,12 +1920,24 @@ "reason" : "unknownType", "symbol" : "GLib.parse_debug_string" }, + { + "cIdentifier" : "g_path_buf_equal", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.path_buf_equal" + }, { "cIdentifier" : "g_pattern_match", - "detail" : "parameter 'string_reversed' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.pattern_match" }, + { + "cIdentifier" : "g_pattern_match_string", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", + "symbol" : "GLib.pattern_match_string" + }, { "cIdentifier" : "g_pointer_bit_lock", "detail" : "parameter 'address' C type 'void*' is a pointer", @@ -2084,8 +1964,8 @@ }, { "cIdentifier" : "g_prefix_error", - "detail" : "'err' has direction=inout", - "reason" : "inoutParameter", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.prefix_error" }, { @@ -2096,32 +1976,32 @@ }, { "cIdentifier" : "g_print", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.print" }, { "cIdentifier" : "g_printerr", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.printerr" }, { "cIdentifier" : "g_printf", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.printf" }, { "cIdentifier" : "g_printf_string_upper_bound", - "detail" : "parameter 'args': va_list parameters are permanently unbridgeable", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.printf_string_upper_bound" }, { "cIdentifier" : "g_private_new", - "detail" : "parameter 'notify': callback 'GLib.DestroyNotify' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.private_new" }, { @@ -2132,49 +2012,49 @@ }, { "cIdentifier" : "g_propagate_prefixed_error", - "detail" : "parameter 'dest': 'GLib.Error' shadows reserved type 'Error'", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.propagate_prefixed_error" }, { "cIdentifier" : "g_ptr_array_find", - "detail" : "parameter 'haystack': ptrArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.ptr_array_find" }, { "cIdentifier" : "g_ptr_array_find_with_equal_func", - "detail" : "parameter 'haystack': ptrArray container with 1 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.ptr_array_find_with_equal_func" }, { "cIdentifier" : "g_ptr_array_new_from_array", - "detail" : "parameter 'data': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.ptr_array_new_from_array" }, { "cIdentifier" : "g_ptr_array_new_from_null_terminated_array", - "detail" : "parameter 'data': C array has no length annotation", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.ptr_array_new_from_null_terminated_array" }, { "cIdentifier" : "g_ptr_array_new_take", - "detail" : "parameter 'data': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.ptr_array_new_take" }, { "cIdentifier" : "g_ptr_array_new_take_null_terminated", - "detail" : "parameter 'data': C array has no length annotation", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.ptr_array_new_take_null_terminated" }, { "cIdentifier" : "g_qsort_with_data", - "detail" : "parameter 'compare_func': callback 'GLib.CompareDataFunc' not yet supported as a mapped type", + "detail" : "callback param 'compare_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.qsort_with_data" }, @@ -2198,7 +2078,7 @@ }, { "cIdentifier" : "g_rc_box_release_full", - "detail" : "parameter 'clear_func': callback 'GLib.DestroyNotify' not yet supported as a mapped type", + "detail" : "callback param 'clear_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.rc_box_release_full" }, @@ -2238,10 +2118,40 @@ "reason" : "unknownType", "symbol" : "GLib.ref_string_release" }, + { + "cIdentifier" : "g_regex_check_replacement", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.regex_check_replacement" + }, + { + "cIdentifier" : "g_regex_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.regex_error_quark" + }, + { + "cIdentifier" : "g_regex_escape_nul", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.regex_escape_nul" + }, + { + "cIdentifier" : "g_regex_escape_string", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.regex_escape_string" + }, + { + "cIdentifier" : "g_regex_match_simple", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.regex_match_simple" + }, { "cIdentifier" : "g_regex_split_simple", - "detail" : "C array has no length annotation", - "reason" : "arrayWithoutLength", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.regex_split_simple" }, { @@ -2258,8 +2168,8 @@ }, { "cIdentifier" : "g_return_if_fail_warning", - "detail" : "parameter 'log_domain' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.return_if_fail_warning" }, { @@ -2270,80 +2180,80 @@ }, { "cIdentifier" : "g_sequence_foreach_range", - "detail" : "parameter 'begin': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_foreach_range" }, { "cIdentifier" : "g_sequence_get", - "detail" : "parameter 'iter': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_get" }, { "cIdentifier" : "g_sequence_insert_before", - "detail" : "parameter 'iter': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_insert_before" }, { "cIdentifier" : "g_sequence_move", - "detail" : "parameter 'src': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_move" }, { "cIdentifier" : "g_sequence_move_range", - "detail" : "parameter 'dest': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_move_range" }, { "cIdentifier" : "g_sequence_range_get_midpoint", - "detail" : "parameter 'begin': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_range_get_midpoint" }, { "cIdentifier" : "g_sequence_remove", - "detail" : "parameter 'iter': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_remove" }, { "cIdentifier" : "g_sequence_remove_range", - "detail" : "parameter 'begin': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_remove_range" }, { "cIdentifier" : "g_sequence_set", - "detail" : "parameter 'iter': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_set" }, { "cIdentifier" : "g_sequence_sort_changed", - "detail" : "parameter 'iter': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_sort_changed" }, { "cIdentifier" : "g_sequence_sort_changed_iter", - "detail" : "parameter 'iter': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_sort_changed_iter" }, { "cIdentifier" : "g_sequence_swap", - "detail" : "parameter 'a': 'GLib.SequenceIter' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.sequence_swap" }, { "cIdentifier" : "g_set_error", - "detail" : "out-param 'err': 'GLib.Error' shadows reserved type 'Error'", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.set_error" }, { @@ -2354,14 +2264,14 @@ }, { "cIdentifier" : "g_set_print_handler", - "detail" : "parameter 'func': callback 'GLib.PrintFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.set_print_handler" }, { "cIdentifier" : "g_set_printerr_handler", - "detail" : "parameter 'func': callback 'GLib.PrintFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.set_printerr_handler" }, { @@ -2376,30 +2286,54 @@ "reason" : "unknownType", "symbol" : "GLib.slice_get_config_state" }, + { + "cIdentifier" : "g_slist_pop_allocator", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.slist_pop_allocator" + }, { "cIdentifier" : "g_slist_push_allocator", - "detail" : "parameter 'allocator': 'GLib.Allocator' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.slist_push_allocator" }, { "cIdentifier" : "g_snprintf", - "detail" : "parameter 'string' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.snprintf" }, { "cIdentifier" : "g_sort_array", - "detail" : "parameter 'array': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.sort_array" }, + { + "cIdentifier" : "g_source_remove", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.source_remove" + }, { "cIdentifier" : "g_source_remove_by_funcs_user_data", - "detail" : "parameter 'funcs': 'GLib.SourceFuncs' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.source_remove_by_funcs_user_data" }, + { + "cIdentifier" : "g_source_remove_by_user_data", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.source_remove_by_user_data" + }, + { + "cIdentifier" : "g_source_set_name_by_id", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.source_set_name_by_id" + }, { "cIdentifier" : "g_spawn_async", "detail" : "parameter 'working_directory' is a nullable string", @@ -2438,8 +2372,8 @@ }, { "cIdentifier" : "g_sprintf", - "detail" : "parameter 'string' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.sprintf" }, { @@ -2492,8 +2426,8 @@ }, { "cIdentifier" : "g_strconcat", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.strconcat" }, { @@ -2516,14 +2450,14 @@ }, { "cIdentifier" : "g_strdup_printf", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.strdup_printf" }, { "cIdentifier" : "g_strdup_vprintf", - "detail" : "parameter 'args': va_list parameters are permanently unbridgeable", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.strdup_vprintf" }, { @@ -2546,8 +2480,8 @@ }, { "cIdentifier" : "g_strjoin", - "detail" : "parameter 'separator' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.strjoin" }, { @@ -2624,44 +2558,44 @@ }, { "cIdentifier" : "g_test_add_data_func", - "detail" : "parameter 'test_func': callback 'GLib.TestDataFunc' not yet supported as a mapped type", + "detail" : "callback param 'test_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.test_add_data_func" }, { "cIdentifier" : "g_test_add_data_func_full", - "detail" : "parameter 'test_func': callback 'GLib.TestDataFunc' not yet supported as a mapped type", + "detail" : "callback param 'test_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.test_add_data_func_full" }, { "cIdentifier" : "g_test_add_func", - "detail" : "parameter 'test_func': callback 'GLib.TestFunc' not yet supported as a mapped type", + "detail" : "callback param 'test_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.test_add_func" }, { "cIdentifier" : "g_test_add_vtable", - "detail" : "parameter 'data_setup': callback 'GLib.TestFixtureFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_add_vtable" }, { "cIdentifier" : "g_test_build_filename", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_build_filename" }, { "cIdentifier" : "g_test_create_case", - "detail" : "parameter 'data_setup': callback 'GLib.TestFixtureFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_create_case" }, { "cIdentifier" : "g_test_create_suite", - "detail" : "'GLib.TestSuite' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_create_suite" }, { @@ -2672,20 +2606,20 @@ }, { "cIdentifier" : "g_test_fail_printf", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_fail_printf" }, { "cIdentifier" : "g_test_get_filename", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_get_filename" }, { "cIdentifier" : "g_test_get_root", - "detail" : "'GLib.TestSuite' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_get_root" }, { @@ -2696,43 +2630,43 @@ }, { "cIdentifier" : "g_test_incomplete_printf", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_incomplete_printf" }, { "cIdentifier" : "g_test_init", - "detail" : "parameter 'argc' C type 'int*' is a pointer", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_init" }, { "cIdentifier" : "g_test_log_set_fatal_handler", - "detail" : "parameter 'log_func': callback 'GLib.TestLogFatalFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_log_set_fatal_handler" }, { "cIdentifier" : "g_test_maximized_result", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_maximized_result" }, { "cIdentifier" : "g_test_message", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_message" }, { "cIdentifier" : "g_test_minimized_result", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_minimized_result" }, { "cIdentifier" : "g_test_queue_destroy", - "detail" : "parameter 'destroy_func': callback 'GLib.DestroyNotify' not yet supported as a mapped type", + "detail" : "callback param 'destroy_func' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.test_queue_destroy" }, @@ -2750,8 +2684,8 @@ }, { "cIdentifier" : "g_test_skip_printf", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.test_skip_printf" }, { @@ -2768,98 +2702,164 @@ }, { "cIdentifier" : "g_thread_create", - "detail" : "parameter 'func': callback 'GLib.ThreadFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.thread_create" }, { "cIdentifier" : "g_thread_create_full", - "detail" : "parameter 'func': callback 'GLib.ThreadFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.thread_create_full" }, + { + "cIdentifier" : "g_thread_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_error_quark" + }, + { + "cIdentifier" : "g_thread_exit", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_exit" + }, { "cIdentifier" : "g_thread_foreach", - "detail" : "parameter 'thread_func': callback 'GLib.Func' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.thread_foreach" }, + { + "cIdentifier" : "g_thread_get_initialized", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", + "symbol" : "GLib.thread_get_initialized" + }, { "cIdentifier" : "g_thread_init", - "detail" : "C symbol 'g_thread_init' is not exported by the system library", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.thread_init" }, { "cIdentifier" : "g_thread_init_with_errorcheck_mutexes", - "detail" : "C symbol 'g_thread_init_with_errorcheck_mutexes' is not exported by the system library", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.thread_init_with_errorcheck_mutexes" }, + { + "cIdentifier" : "g_thread_pool_get_max_idle_time", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_pool_get_max_idle_time" + }, + { + "cIdentifier" : "g_thread_pool_get_max_unused_threads", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_pool_get_max_unused_threads" + }, + { + "cIdentifier" : "g_thread_pool_get_num_unused_threads", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_pool_get_num_unused_threads" + }, + { + "cIdentifier" : "g_thread_pool_set_max_idle_time", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_pool_set_max_idle_time" + }, + { + "cIdentifier" : "g_thread_pool_set_max_unused_threads", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_pool_set_max_unused_threads" + }, + { + "cIdentifier" : "g_thread_pool_stop_unused_threads", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_pool_stop_unused_threads" + }, + { + "cIdentifier" : "g_thread_self", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_self" + }, + { + "cIdentifier" : "g_thread_yield", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.thread_yield" + }, { "cIdentifier" : "g_time_val_from_iso8601", - "detail" : "caller-allocates out-param 'time_' (no buffer size in GIR)", - "reason" : "outParameter", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.time_val_from_iso8601" }, { "cIdentifier" : "g_timeout_add", - "detail" : "parameter 'function': callback 'GLib.SourceFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "shadowedSymbol", + "reason" : "shadowedSymbol", "symbol" : "GLib.timeout_add" }, { "cIdentifier" : "g_timeout_add_full", - "detail" : "parameter 'function': callback 'GLib.SourceFunc' not yet supported as a mapped type", + "detail" : "callback param 'function' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.timeout_add_full" }, { "cIdentifier" : "g_timeout_add_once", - "detail" : "parameter 'function': callback 'GLib.SourceOnceFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.timeout_add_once" }, { "cIdentifier" : "g_timeout_add_seconds", - "detail" : "parameter 'function': callback 'GLib.SourceFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "shadowedSymbol", + "reason" : "shadowedSymbol", "symbol" : "GLib.timeout_add_seconds" }, { "cIdentifier" : "g_timeout_add_seconds_full", - "detail" : "parameter 'function': callback 'GLib.SourceFunc' not yet supported as a mapped type", + "detail" : "callback param 'function' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GLib.timeout_add_seconds_full" }, { "cIdentifier" : "g_timeout_add_seconds_once", - "detail" : "parameter 'function': callback 'GLib.SourceOnceFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.timeout_add_seconds_once" }, { "cIdentifier" : "g_trash_stack_height", - "detail" : "parameter 'stack_p': 'GLib.TrashStack' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.trash_stack_height" }, { "cIdentifier" : "g_trash_stack_peek", - "detail" : "parameter 'stack_p': 'GLib.TrashStack' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.trash_stack_peek" }, { "cIdentifier" : "g_trash_stack_pop", - "detail" : "parameter 'stack_p': 'GLib.TrashStack' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.trash_stack_pop" }, { "cIdentifier" : "g_trash_stack_push", - "detail" : "parameter 'stack_p': 'GLib.TrashStack' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.trash_stack_push" }, { @@ -2898,6 +2898,18 @@ "reason" : "arrayWithoutLength", "symbol" : "GLib.unicode_canonical_ordering" }, + { + "cIdentifier" : "g_unicode_script_from_iso15924", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.unicode_script_from_iso15924" + }, + { + "cIdentifier" : "g_unicode_script_to_iso15924", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.unicode_script_to_iso15924" + }, { "cIdentifier" : "g_unlink", "detail" : "C symbol 'g_unlink' is not exported by the system library", @@ -2906,74 +2918,122 @@ }, { "cIdentifier" : "g_uri_build", - "detail" : "parameter 'userinfo' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_build" }, { "cIdentifier" : "g_uri_build_with_user", - "detail" : "parameter 'user' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_build_with_user" }, + { + "cIdentifier" : "g_uri_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_error_quark" + }, { "cIdentifier" : "g_uri_escape_bytes", - "detail" : "parameter 'unescaped': C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_escape_bytes" }, { "cIdentifier" : "g_uri_escape_string", - "detail" : "parameter 'reserved_chars_allowed' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_escape_string" }, + { + "cIdentifier" : "g_uri_is_valid", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_is_valid" + }, { "cIdentifier" : "g_uri_join", - "detail" : "parameter 'scheme' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_join" }, { "cIdentifier" : "g_uri_join_with_user", - "detail" : "parameter 'scheme' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_join_with_user" }, { "cIdentifier" : "g_uri_list_extract_uris", - "detail" : "C array has no length annotation", - "reason" : "arrayWithoutLength", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_list_extract_uris" }, + { + "cIdentifier" : "g_uri_parse", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_parse" + }, { "cIdentifier" : "g_uri_parse_params", - "detail" : "hashTable container with 2 element(s) not yet bridged", - "reason" : "containerType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_parse_params" }, + { + "cIdentifier" : "g_uri_parse_scheme", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_parse_scheme" + }, + { + "cIdentifier" : "g_uri_peek_scheme", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_peek_scheme" + }, { "cIdentifier" : "g_uri_resolve_relative", - "detail" : "parameter 'base_uri_string' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_resolve_relative" }, + { + "cIdentifier" : "g_uri_split", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_split" + }, + { + "cIdentifier" : "g_uri_split_network", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_split_network" + }, + { + "cIdentifier" : "g_uri_split_with_user", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.uri_split_with_user" + }, { "cIdentifier" : "g_uri_unescape_bytes", - "detail" : "parameter 'illegal_characters' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_unescape_bytes" }, { "cIdentifier" : "g_uri_unescape_segment", - "detail" : "parameter 'escaped_string' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_unescape_segment" }, { "cIdentifier" : "g_uri_unescape_string", - "detail" : "parameter 'illegal_characters' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.uri_unescape_string" }, { @@ -3042,66 +3102,112 @@ "reason" : "unknownType", "symbol" : "GLib.variant_get_gtype" }, + { + "cIdentifier" : "g_variant_is_object_path", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.variant_is_object_path" + }, + { + "cIdentifier" : "g_variant_is_signature", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.variant_is_signature" + }, { "cIdentifier" : "g_variant_parse", - "detail" : "parameter 'limit' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.variant_parse" }, { "cIdentifier" : "g_variant_parse_error_print_context", - "detail" : "parameter 'error': 'GLib.Error' shadows reserved type 'Error'", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.variant_parse_error_print_context" }, + { + "cIdentifier" : "g_variant_parse_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.variant_parse_error_quark" + }, + { + "cIdentifier" : "g_variant_parser_get_error_quark", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.variant_parser_get_error_quark" + }, + { + "cIdentifier" : "g_variant_type_checked_", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.variant_type_checked_" + }, + { + "cIdentifier" : "g_variant_type_string_get_depth_", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.variant_type_string_get_depth_" + }, + { + "cIdentifier" : "g_variant_type_string_is_valid", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GLib.variant_type_string_is_valid" + }, { "cIdentifier" : "g_variant_type_string_scan", - "detail" : "parameter 'limit' is a nullable string", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GLib.variant_type_string_scan" }, { "cIdentifier" : "g_vasprintf", - "detail" : "parameter 'args': va_list parameters are permanently unbridgeable", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.vasprintf" }, { "cIdentifier" : "g_vfprintf", - "detail" : "parameter 'file' C type 'FILE*' is a pointer", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.vfprintf" }, { "cIdentifier" : "g_vprintf", - "detail" : "parameter 'args': va_list parameters are permanently unbridgeable", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.vprintf" }, { "cIdentifier" : "g_vsnprintf", - "detail" : "parameter 'string' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.vsnprintf" }, { "cIdentifier" : "g_vsprintf", - "detail" : "parameter 'string' is not a single const input string ('gchar*')", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.vsprintf" }, { "cIdentifier" : "g_warn_message", - "detail" : "parameter 'domain' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GLib.warn_message" } ], "module" : "GLib", "stats" : { - "boundCallables" : 333, - "boundTypes" : 242, + "boundCallables" : 271, + "boundCallbacks" : 61, + "boundSignals" : 0, + "boundTypes" : 287, "totalCallables" : 724, + "totalCallbacks" : 61, + "totalSignals" : 0, "totalTypes" : 367 } } diff --git a/docs/skip-baseline/tier1/GObject.json b/docs/skip-baseline/tier1/GObject.json index fa875a7..746479e 100644 --- a/docs/skip-baseline/tier1/GObject.json +++ b/docs/skip-baseline/tier1/GObject.json @@ -2,70 +2,40 @@ "entries" : [ { "cIdentifier" : "GBaseFinalizeFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'BaseFinalizeFunc' has unmappable param/return: callback 'BaseFinalizeFunc' param 'g_class' unmappable: 'GObject.TypeClass' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.BaseFinalizeFunc" }, { "cIdentifier" : "GBaseInitFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'BaseInitFunc' has unmappable param/return: callback 'BaseInitFunc' param 'g_class' unmappable: 'GObject.TypeClass' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.BaseInitFunc" }, - { - "cIdentifier" : "GBindingTransformFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.BindingTransformFunc" - }, - { - "cIdentifier" : "GBoxedCopyFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.BoxedCopyFunc" - }, - { - "cIdentifier" : "GBoxedFreeFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.BoxedFreeFunc" - }, { "cIdentifier" : "GCClosure", "detail" : "no GType registration", "reason" : "plainRecord", "symbol" : "GObject.CClosure" }, - { - "cIdentifier" : "GCallback", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.Callback" - }, { "cIdentifier" : "GClassFinalizeFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'ClassFinalizeFunc' has unmappable param/return: callback 'ClassFinalizeFunc' param 'g_class' unmappable: 'GObject.TypeClass' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.ClassFinalizeFunc" }, { "cIdentifier" : "GClassInitFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'ClassInitFunc' has unmappable param/return: callback 'ClassInitFunc' param 'g_class' unmappable: 'GObject.TypeClass' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.ClassInitFunc" }, { "cIdentifier" : "GClosureMarshal", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'ClosureMarshal' has unmappable param/return: callback 'ClosureMarshal' param 'param_values' unmappable: C array bridging not yet implemented", "reason" : "callbackWithoutUserData", "symbol" : "GObject.ClosureMarshal" }, - { - "cIdentifier" : "GClosureNotify", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.ClosureNotify" - }, { "cIdentifier" : "GClosureNotifyData", "detail" : "no GType registration", @@ -104,13 +74,13 @@ }, { "cIdentifier" : "GInstanceInitFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'InstanceInitFunc' has unmappable param/return: callback 'InstanceInitFunc' param 'instance' unmappable: 'GObject.TypeInstance' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.InstanceInitFunc" }, { "cIdentifier" : "GInterfaceFinalizeFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'InterfaceFinalizeFunc' has unmappable param/return: callback 'InterfaceFinalizeFunc' param 'g_iface' unmappable: 'GObject.TypeInterface' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.InterfaceFinalizeFunc" }, @@ -122,7 +92,7 @@ }, { "cIdentifier" : "GInterfaceInitFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'InterfaceInitFunc' has unmappable param/return: callback 'InterfaceInitFunc' param 'g_iface' unmappable: 'GObject.TypeInterface' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.InterfaceInitFunc" }, @@ -144,24 +114,6 @@ "reason" : "plainRecord", "symbol" : "GObject.ObjectConstructParam" }, - { - "cIdentifier" : "GObjectFinalizeFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.ObjectFinalizeFunc" - }, - { - "cIdentifier" : "GObjectGetPropertyFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.ObjectGetPropertyFunc" - }, - { - "cIdentifier" : "GObjectSetPropertyFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.ObjectSetPropertyFunc" - }, { "cIdentifier" : "GParamSpecClass", "detail" : "GObject class struct for 'ParamSpec'", @@ -188,25 +140,25 @@ }, { "cIdentifier" : "GSignalAccumulator", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'SignalAccumulator' has unmappable param/return: callback 'SignalAccumulator' param 'ihint' unmappable: 'GObject.SignalInvocationHint' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.SignalAccumulator" }, { "cIdentifier" : "GSignalCMarshaller", - "detail" : "callback 'GObject.ClosureMarshal' not yet supported as a mapped type", + "detail" : "callback 'ClosureMarshal' param 'param_values' unmappable: C array bridging not yet implemented", "reason" : "callbackWithoutUserData", "symbol" : "GObject.SignalCMarshaller" }, { "cIdentifier" : "GSignalCVaMarshaller", - "detail" : "callback 'GObject.VaClosureMarshal' not yet supported as a mapped type", + "detail" : "callback 'VaClosureMarshal' param 'instance' unmappable: 'GObject.TypeInstance' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.SignalCVaMarshaller" }, { "cIdentifier" : "GSignalEmissionHook", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'SignalEmissionHook' has unmappable param/return: callback 'SignalEmissionHook' param 'ihint' unmappable: 'GObject.SignalInvocationHint' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.SignalEmissionHook" }, @@ -222,12 +174,6 @@ "reason" : "plainRecord", "symbol" : "GObject.SignalQuery" }, - { - "cIdentifier" : "GToggleNotify", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.ToggleNotify" - }, { "cIdentifier" : "GTypeClass", "detail" : "no GType registration", @@ -236,7 +182,7 @@ }, { "cIdentifier" : "GTypeClassCacheFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'TypeClassCacheFunc' has unmappable param/return: callback 'TypeClassCacheFunc' param 'g_class' unmappable: 'GObject.TypeClass' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.TypeClassCacheFunc" }, @@ -266,7 +212,7 @@ }, { "cIdentifier" : "GTypeInterfaceCheckFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'TypeInterfaceCheckFunc' has unmappable param/return: callback 'TypeInterfaceCheckFunc' param 'g_iface' unmappable: 'GObject.TypeInterface' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.TypeInterfaceCheckFunc" }, @@ -284,28 +230,16 @@ }, { "cIdentifier" : "GTypePluginCompleteInterfaceInfo", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'TypePluginCompleteInterfaceInfo' has unmappable param/return: callback 'TypePluginCompleteInterfaceInfo' param 'info' unmappable: 'GObject.InterfaceInfo' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.TypePluginCompleteInterfaceInfo" }, { "cIdentifier" : "GTypePluginCompleteTypeInfo", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'TypePluginCompleteTypeInfo' has unmappable param/return: callback 'TypePluginCompleteTypeInfo' param 'info' unmappable: 'GObject.TypeInfo' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.TypePluginCompleteTypeInfo" }, - { - "cIdentifier" : "GTypePluginUnuse", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.TypePluginUnuse" - }, - { - "cIdentifier" : "GTypePluginUse", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.TypePluginUse" - }, { "cIdentifier" : "GTypeQuery", "detail" : "no GType registration", @@ -314,40 +248,16 @@ }, { "cIdentifier" : "GTypeValueCollectFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'TypeValueCollectFunc' has unmappable param/return: callback 'TypeValueCollectFunc' param 'collect_values' unmappable: C array bridging not yet implemented", "reason" : "callbackWithoutUserData", "symbol" : "GObject.TypeValueCollectFunc" }, - { - "cIdentifier" : "GTypeValueCopyFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.TypeValueCopyFunc" - }, - { - "cIdentifier" : "GTypeValueFreeFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.TypeValueFreeFunc" - }, - { - "cIdentifier" : "GTypeValueInitFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.TypeValueInitFunc" - }, { "cIdentifier" : "GTypeValueLCopyFunc", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'TypeValueLCopyFunc' has unmappable param/return: callback 'TypeValueLCopyFunc' param 'collect_values' unmappable: C array bridging not yet implemented", "reason" : "callbackWithoutUserData", "symbol" : "GObject.TypeValueLCopyFunc" }, - { - "cIdentifier" : "GTypeValuePeekPointerFunc", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.TypeValuePeekPointerFunc" - }, { "cIdentifier" : "GTypeValueTable", "detail" : "no GType registration", @@ -356,22 +266,10 @@ }, { "cIdentifier" : "GVaClosureMarshal", - "detail" : "callback planned for Phase D2", + "detail" : "callback 'VaClosureMarshal' has unmappable param/return: callback 'VaClosureMarshal' param 'instance' unmappable: 'GObject.TypeInstance' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.VaClosureMarshal" }, - { - "cIdentifier" : "GValueTransform", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.ValueTransform" - }, - { - "cIdentifier" : "GWeakNotify", - "detail" : "callback planned for Phase D2", - "reason" : "callbackWithoutUserData", - "symbol" : "GObject.WeakNotify" - }, { "cIdentifier" : "GWeakRef", "detail" : "no GType registration", @@ -386,34 +284,178 @@ }, { "cIdentifier" : "g_boxed_type_register_static", - "detail" : "parameter 'boxed_copy': callback 'GObject.BoxedCopyFunc' not yet supported as a mapped type", + "detail" : "callback param 'boxed_copy' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GObject.boxed_type_register_static" }, + { + "cIdentifier" : "g_cclosure_marshal_BOOLEAN__BOXED_BOXED", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_BOOLEAN__BOXED_BOXED" + }, + { + "cIdentifier" : "g_cclosure_marshal_BOOLEAN__FLAGS", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_BOOLEAN__FLAGS" + }, + { + "cIdentifier" : "g_cclosure_marshal_STRING__OBJECT_POINTER", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_STRING__OBJECT_POINTER" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__BOOLEAN", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__BOOLEAN" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__BOXED", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__BOXED" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__CHAR", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__CHAR" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__DOUBLE", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__DOUBLE" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__ENUM", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__ENUM" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__FLAGS", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__FLAGS" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__FLOAT", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__FLOAT" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__INT", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__INT" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__LONG", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__LONG" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__OBJECT", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__OBJECT" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__PARAM", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__PARAM" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__POINTER", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__POINTER" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__STRING", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__STRING" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__UCHAR", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__UCHAR" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__UINT", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__UINT" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__UINT_POINTER", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__UINT_POINTER" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__ULONG", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__ULONG" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__VARIANT", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__VARIANT" + }, + { + "cIdentifier" : "g_cclosure_marshal_VOID__VOID", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_VOID__VOID" + }, + { + "cIdentifier" : "g_cclosure_marshal_generic", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.cclosure_marshal_generic" + }, { "cIdentifier" : "g_cclosure_new", - "detail" : "parameter 'callback_func': callback 'GObject.Callback' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.cclosure_new" }, { "cIdentifier" : "g_cclosure_new_object", - "detail" : "parameter 'callback_func': callback 'GObject.Callback' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.cclosure_new_object" }, { "cIdentifier" : "g_cclosure_new_object_swap", - "detail" : "parameter 'callback_func': callback 'GObject.Callback' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.cclosure_new_object_swap" }, { "cIdentifier" : "g_cclosure_new_swap", - "detail" : "parameter 'callback_func': callback 'GObject.Callback' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.cclosure_new_swap" }, + { + "cIdentifier" : "g_clear_object", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", + "symbol" : "GObject.clear_object" + }, { "cIdentifier" : "g_clear_signal_handler", "detail" : "parameter 'handler_id_ptr' C type 'gulong*' is a pointer", @@ -434,13 +476,13 @@ }, { "cIdentifier" : "g_signal_group_connect_data", - "detail" : "parameter 'c_handler': callback 'GObject.Callback' not yet supported as a mapped type", + "detail" : "callback param 'c_handler' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GObject.connect_data" }, { "cIdentifier" : "g_signal_group_connect_swapped", - "detail" : "parameter 'c_handler': callback 'GObject.Callback' not yet supported as a mapped type", + "detail" : "callback param 'c_handler' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GObject.connect_swapped" }, @@ -600,6 +642,12 @@ "reason" : "unknownType", "symbol" : "GObject.param_spec_object" }, + { + "cIdentifier" : "g_param_spec_override", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", + "symbol" : "GObject.param_spec_override" + }, { "cIdentifier" : "g_param_spec_param", "detail" : "parameter 'nick' is a nullable string", @@ -650,8 +698,8 @@ }, { "cIdentifier" : "g_param_spec_value_array", - "detail" : "parameter 'nick' is a nullable string", - "reason" : "unknownType", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.param_spec_value_array" }, { @@ -698,7 +746,7 @@ }, { "cIdentifier" : "g_signal_add_emission_hook", - "detail" : "parameter 'hook_func': callback 'GObject.SignalEmissionHook' not yet supported as a mapped type", + "detail" : "parameter 'hook_func': callback 'SignalEmissionHook' param 'ihint' unmappable: 'GObject.SignalInvocationHint' has no GType registration or lifetime functions", "reason" : "callbackWithoutUserData", "symbol" : "GObject.signal_add_emission_hook" }, @@ -710,38 +758,38 @@ }, { "cIdentifier" : "g_signal_chain_from_overridden_handler", - "detail" : "parameter 'instance': 'GObject.TypeInstance' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_chain_from_overridden_handler" }, { "cIdentifier" : "g_signal_connect_data", - "detail" : "parameter 'c_handler': callback 'GObject.Callback' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_connect_data" }, { "cIdentifier" : "g_signal_connect_object", - "detail" : "parameter 'instance': 'GObject.TypeInstance' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_connect_object" }, { "cIdentifier" : "g_signal_emit", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_emit" }, { "cIdentifier" : "g_signal_emit_by_name", - "detail" : "variadic ('...') parameter", - "reason" : "varargs", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_emit_by_name" }, { "cIdentifier" : "g_signal_emit_valist", - "detail" : "parameter 'instance': 'GObject.TypeInstance' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_emit_valist" }, { @@ -764,31 +812,31 @@ }, { "cIdentifier" : "g_signal_new", - "detail" : "parameter 'accumulator': callback 'GObject.SignalAccumulator' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_new" }, { "cIdentifier" : "g_signal_new_class_handler", - "detail" : "parameter 'class_handler': callback 'GObject.Callback' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_new_class_handler" }, { "cIdentifier" : "g_signal_new_valist", - "detail" : "parameter 'accumulator': callback 'GObject.SignalAccumulator' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_new_valist" }, { "cIdentifier" : "g_signal_newv", - "detail" : "parameter 'accumulator': callback 'GObject.SignalAccumulator' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_newv" }, { "cIdentifier" : "g_signal_override_class_handler", - "detail" : "parameter 'class_handler': callback 'GObject.Callback' not yet supported as a mapped type", + "detail" : "callback param 'class_handler' deferred to Phase D4.3", "reason" : "callbackWithoutUserData", "symbol" : "GObject.signal_override_class_handler" }, @@ -800,20 +848,32 @@ }, { "cIdentifier" : "g_signal_set_va_marshaller", - "detail" : "parameter 'va_marshaller': callback 'GObject.VaClosureMarshal' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.signal_set_va_marshaller" }, + { + "cIdentifier" : "g_source_set_closure", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.source_set_closure" + }, + { + "cIdentifier" : "g_source_set_dummy_callback", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.source_set_dummy_callback" + }, { "cIdentifier" : "g_type_add_class_cache_func", - "detail" : "parameter 'cache_func': callback 'GObject.TypeClassCacheFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_add_class_cache_func" }, { "cIdentifier" : "g_type_add_interface_check", - "detail" : "parameter 'check_func': callback 'GObject.TypeInterfaceCheckFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_add_interface_check" }, { @@ -824,8 +884,8 @@ }, { "cIdentifier" : "g_type_check_class_cast", - "detail" : "parameter 'g_class': 'GObject.TypeClass' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_check_class_cast" }, { @@ -842,8 +902,8 @@ }, { "cIdentifier" : "g_type_check_instance_cast", - "detail" : "parameter 'instance': 'GObject.TypeInstance' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_check_instance_cast" }, { @@ -866,38 +926,38 @@ }, { "cIdentifier" : "g_type_class_adjust_private_offset", - "detail" : "parameter 'private_size_or_offset' C type 'gint*' is a pointer", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_class_adjust_private_offset" }, { "cIdentifier" : "g_type_class_get", - "detail" : "'GObject.TypeClass' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_class_get" }, { "cIdentifier" : "g_type_class_peek", - "detail" : "'GObject.TypeClass' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_class_peek" }, { "cIdentifier" : "g_type_class_peek_static", - "detail" : "'GObject.TypeClass' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_class_peek_static" }, { "cIdentifier" : "g_type_class_ref", - "detail" : "'GObject.TypeClass' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_class_ref" }, { "cIdentifier" : "g_type_create_instance", - "detail" : "'GObject.TypeInstance' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_create_instance" }, { @@ -936,22 +996,34 @@ "reason" : "unknownType", "symbol" : "GObject.type_get_plugin" }, + { + "cIdentifier" : "g_type_interface_add_prerequisite", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.type_interface_add_prerequisite" + }, { "cIdentifier" : "g_type_interface_get_plugin", - "detail" : "return type: interface return", - "reason" : "unknownType", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_interface_get_plugin" }, + { + "cIdentifier" : "g_type_interface_instantiatable_prerequisite", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.type_interface_instantiatable_prerequisite" + }, { "cIdentifier" : "g_type_interface_peek", - "detail" : "parameter 'instance_class': 'GObject.TypeClass' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_interface_peek" }, { "cIdentifier" : "g_type_interface_prerequisites", - "detail" : "C array bridging not yet implemented", - "reason" : "arrayWithoutLength", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", "symbol" : "GObject.type_interface_prerequisites" }, { @@ -992,34 +1064,46 @@ }, { "cIdentifier" : "g_type_register_static_simple", - "detail" : "parameter 'class_init': callback 'GObject.ClassInitFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_register_static_simple" }, { "cIdentifier" : "g_type_remove_class_cache_func", - "detail" : "parameter 'cache_func': callback 'GObject.TypeClassCacheFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_remove_class_cache_func" }, { "cIdentifier" : "g_type_remove_interface_check", - "detail" : "parameter 'check_func': callback 'GObject.TypeInterfaceCheckFunc' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_remove_interface_check" }, { "cIdentifier" : "g_type_value_table_peek", - "detail" : "'GObject.TypeValueTable' has no GType registration or lifetime functions", - "reason" : "plainRecord", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.type_value_table_peek" }, { "cIdentifier" : "g_value_register_transform_func", - "detail" : "parameter 'transform_func': callback 'GObject.ValueTransform' not yet supported as a mapped type", - "reason" : "callbackWithoutUserData", + "detail" : "notIntrospectable", + "reason" : "notIntrospectable", "symbol" : "GObject.value_register_transform_func" }, + { + "cIdentifier" : "g_value_type_compatible", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.value_type_compatible" + }, + { + "cIdentifier" : "g_value_type_transformable", + "detail" : "deprecatedRemoved", + "reason" : "deprecatedRemoved", + "symbol" : "GObject.value_type_transformable" + }, { "cIdentifier" : "g_variant_get_gtype", "detail" : "C symbol 'g_variant_get_gtype' is not exported by the system library", @@ -1035,9 +1119,13 @@ ], "module" : "GObject", "stats" : { - "boundCallables" : 143, - "boundTypes" : 60, + "boundCallables" : 112, + "boundCallbacks" : 32, + "boundSignals" : 3, + "boundTypes" : 77, "totalCallables" : 284, + "totalCallbacks" : 34, + "totalSignals" : 3, "totalTypes" : 122 } } diff --git a/smoke/SmokeTests.swift b/smoke/SmokeTests.swift index bfe89ec..b49876b 100644 --- a/smoke/SmokeTests.swift +++ b/smoke/SmokeTests.swift @@ -60,42 +60,40 @@ struct SmokeTests { // the process once enough alloc/free cycles run. The loops make such a bug // deterministic rather than intermittent. - @Test("Boxed record copies a borrowed return and frees it on deinit") - func boxedBorrowedReturnRoundtrips() { - // g_variant_type_checked_ returns a borrowed pointer; the wrapper copies - // it (g_variant_type_copy) and frees the copy (g_variant_type_free) on - // deinit. Freeing the borrowed original instead would corrupt GLib's - // internal type table. - for _ in 0..<5000 { - let t = variantTypeChecked(typeString: "(sias)") - #expect(UInt(bitPattern: t.pointer) != 0) + @Test("Signal roundtrip: notify::source fires on property change, disconnect prevents re-fire") + func notifySignalRoundtrip() { + let group = BindingGroup() + let obj = BindingGroup() + var fired = false + + var handler = group.connectNotify(detail: "source") { _, _ in + fired = true } + + group.setSource(source: obj) + #expect(fired) + + fired = false + handler.disconnect() + + group.setSource(source: nil) + #expect(!fired) } - @Test("Boxed record adopts a full-transfer return and frees it on deinit") - func boxedFullTransferReturnRoundtrips() throws { - // g_uri_parse returns transfer-full GUri*; the wrapper adopts it and - // frees with g_uri_unref on deinit. A missing unref leaks; a double - // unref aborts. - for _ in 0..<5000 { - let uri = try uriParse(uriString: "https://example.com/a/b?q=1#frag", flags: []) - #expect(UInt(bitPattern: uri.pointer) != 0) + @Test("Non-detailed signal connect: bare notify fires on property mutation") + func nonDetailedSignal() { + let group = BindingGroup() + var fired = false + var handler = group.connectNotify(detail: nil) { _, _ in + fired = true } - } - - @Test("init(retaining:) makes an independently-owned copy") - func boxedRetainingInitIndependentCopy() { - // Copy one base pointer many times through init(retaining:), then free - // every copy. If the copy aliased the base (no real duplication) the - // frees would destroy the base's storage; the final base access would - // then be a use-after-free. - let base = variantTypeChecked(typeString: "as") - var copies: [VariantType] = [] - for _ in 0..<2000 { - copies.append(VariantType(retaining: base.pointer)) - } - copies.removeAll() // 2000 independent frees - #expect(UInt(bitPattern: base.pointer) != 0) // base survives + let obj = BindingGroup() + group.setSource(source: obj) // property mutation fires bare "notify" + #expect(fired) // handler was invoked + fired = false + handler.disconnect() + group.setSource(source: nil) + #expect(!fired) // disconnected — handler not re-invoked } // MARK: - Out-parameters marshalled as tuple returns (C3) @@ -243,23 +241,18 @@ struct SmokeTests { } } - @Test("Pointer-return throwing function: uriParse adopts result! on success and throws GLibError on malformed URI") + @Test("Throwing function: fileReadLink resolves /etc/localtime and throws on nonexistent path") func pointerReturnThrowingFunction() throws { - // uriParse returns Uri (boxed record, pointer-backed) via - // `Uri(takingOwnership: _rawPointer(result!))`. This is the tier-1 - // symbol the plan's Step 8 enumerated for the pointer-return throwing - // `result!` path. - let uri = try uriParse(uriString: "https://example.com/path", flags: .none) - #expect(UInt(bitPattern: uri.pointer) != 0) + // fileReadLink returns a String (or throws GLibError). This tests the + // throwing function body path with a string return. + let link = try fileReadLink(filename: "/etc/localtime") + #expect(!link.isEmpty) - // Malformed URI: missing scheme. g_uri_parse raises G_URI_ERROR/ - // G_URI_ERROR_FAILED — assert the throw carries a non-empty message. do { - _ = try uriParse(uriString: "://bad", flags: .none) - Issue.record("expected uriParse to throw on a malformed URI") - } catch let error as GLibError { - #expect(error.domain != 0) - #expect(!error.message.isEmpty) + _ = try fileReadLink(filename: "/nonexistent/path/that/does/not/exist") + Issue.record("expected fileReadLink to throw") + } catch { + #expect((error as? GLibError) != nil) } } }