swift-java/Sources/JExtractSwiftLib/SwiftTypes/SwiftKnownTypes.swift at f5369986507d438386725ae05a38277273c629c8 · madsodgaard/swift-java · GitHub

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
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift.org project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift.org project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

struct SwiftKnownTypes {
  private let symbolTable: SwiftSymbolTable

  init(symbolTable: SwiftSymbolTable) {
    self.symbolTable = symbolTable
  }

  var bool: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.bool])) }
  var int: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.int])) }
  var uint: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.uint])) }
  var int8: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.int8])) }
  var uint8: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.uint8])) }
  var int16: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.int16])) }
  var uint16: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.uint16])) }
  var int32: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.int32])) }
  var uint32: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.uint32])) }
  var int64: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.int64])) }
  var uint64: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.uint64])) }
  var float: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.float])) }
  var double: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.double])) }
  var unsafeRawPointer: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.unsafeRawPointer])) }
  var unsafeRawBufferPointer: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.unsafeRawBufferPointer])) }
  var unsafeMutableRawPointer: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.unsafeMutableRawPointer])) }
  var string: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.string])) }

  var foundationDataProtocol: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.foundationDataProtocol])) }
  var foundationData: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.foundationData])) }
  var essentialsDataProtocol: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.essentialsDataProtocol])) }
  var essentialsData: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.essentialsData])) }
  var foundationUUID: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.foundationUUID])) }
  var essentialsUUID: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.essentialsUUID]))}

  /// `(UnsafeRawPointer, Long) -> ()` function type.
  ///
  /// Commonly used to initialize a buffer using the passed bytes and length.
  var functionInitializeByteBuffer: SwiftType {
    .function(SwiftFunctionType(
      convention: .c,
      parameters: [
        SwiftParameter(convention: .byValue, parameterName: nil, type: self.unsafeRawPointer), // array base pointer
        SwiftParameter(convention: .byValue, parameterName: nil, type: self.int), // array length
      ],
      resultType: .void))
  }

  func unsafePointer(_ pointeeType: SwiftType) -> SwiftType {
    .nominal(
      SwiftNominalType(
        nominalTypeDecl: symbolTable[.unsafePointer],
        genericArguments: [pointeeType]
      )
    )
  }

  func unsafeMutablePointer(_ pointeeType: SwiftType) -> SwiftType {
    .nominal(
      SwiftNominalType(
        nominalTypeDecl: symbolTable[.unsafeMutablePointer],
        genericArguments: [pointeeType]
      )
    )
  }

  func unsafeBufferPointer(_ elementType: SwiftType) -> SwiftType {
    .nominal(
      SwiftNominalType(
        nominalTypeDecl: symbolTable[.unsafeBufferPointer],
        genericArguments: [elementType]
      )
    )
  }

  func unsafeMutableBufferPointer(_ elementType: SwiftType) -> SwiftType {
    .nominal(
      SwiftNominalType(
        nominalTypeDecl: symbolTable[.unsafeMutableBufferPointer],
        genericArguments: [elementType]
      )
    )
  }

  /// Returns the known representative concrete type if there is one for the
  /// given protocol kind. E.g. `String` for `StringProtocol`
  func representativeType(of knownProtocol: SwiftKnownTypeDeclKind) -> SwiftType? {
    switch knownProtocol {
    case .foundationDataProtocol: return self.foundationData
    case .essentialsDataProtocol: return self.essentialsData
    default: return nil
    }
  }
}