1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
//===--- VTable.swift -----------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import AST
import SILBridging
public struct VTable : CustomStringConvertible, NoReflectionChildren {
public let bridged: BridgedVTable
public init(bridged: BridgedVTable) { self.bridged = bridged }
public struct Entry : CustomStringConvertible, NoReflectionChildren {
public let bridged: BridgedVTableEntry
public enum Kind {
/// The vtable entry is for a method defined directly in this class.
case normal
/// The vtable entry is inherited from the superclass.
case inherited
/// The vtable entry is inherited from the superclass, and overridden in this class.
case overridden
}
fileprivate init(bridged: BridgedVTableEntry) {
self.bridged = bridged
}
public init(kind: Kind, isNonOverridden: Bool, methodDecl: DeclRef, implementation: Function) {
let bridgedKind: BridgedVTableEntry.Kind
switch kind {
case .normal: bridgedKind = .Normal
case .inherited: bridgedKind = .Inherited
case .overridden: bridgedKind = .Override
}
self.bridged = BridgedVTableEntry.create(bridgedKind, isNonOverridden,
methodDecl.bridged, implementation.bridged)
}
public var kind: Kind {
switch bridged.getKind() {
case .Normal: return .normal
case .Inherited: return .inherited
case .Override: return .overridden
default: fatalError()
}
}
public var isNonOverridden: Bool { bridged.isNonOverridden() }
public var methodDecl: DeclRef { DeclRef(bridged: bridged.getMethodDecl()) }
public var implementation: Function { bridged.getImplementation().function }
public var description: String {
return String(taking: bridged.getDebugDescription())
}
}
public struct EntryArray : BridgedRandomAccessCollection {
fileprivate let bridgedTable: BridgedVTable
public let count: Int
init(vTable: VTable) {
self.bridgedTable = vTable.bridged
self.count = vTable.bridged.getNumEntries()
}
public var startIndex: Int { return 0 }
public var endIndex: Int { return count }
public subscript(_ index: Int) -> Entry {
assert(index >= startIndex && index < endIndex)
return Entry(bridged: bridgedTable.getEntry(index))
}
}
public var entries: EntryArray { EntryArray(vTable: self) }
public var `class`: ClassDecl { bridged.getClass().getAs(ClassDecl.self) }
public var specializedClassType: Type? { bridged.getSpecializedClassType().typeOrNil }
public var isSpecialized: Bool { specializedClassType != nil }
public var description: String {
return String(taking: bridged.getDebugDescription())
}
}
extension OptionalBridgedVTable {
public var vTable: VTable? {
if let table {
return VTable(bridged: BridgedVTable(vTable: table))
}
return nil
}
}
|
