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
107
108
109
110
111
|
import WIT
struct GenerationError: Error, CustomStringConvertible {
var description: String
}
func typeNamespace(packageName: PackageNameSyntax, interface: Identifier) throws -> String {
return try "\(ConvertCase.pascalCase(packageName.namespace))\(ConvertCase.pascalCase(packageName.name))\(ConvertCase.pascalCase(interface))"
}
public func generateGuest(context: SemanticsContext) throws -> String {
let printer = SourcePrinter(header: guestPrelude)
let definitionMapping = GeneratedDefinitionMapping()
try TypeGenerator(context: context).generate(printer: printer)
for sourceFile in context.rootPackage.sourceFiles {
for case .world(let world) in sourceFile.items {
var generator = WorldGenerator(
printer: printer,
packageUnit: context.rootPackage,
sourceFile: sourceFile,
world: world,
signatureTranslation: SignatureTranslation(interfaceContext: nil),
context: context,
definitionMapping: definitionMapping
)
try generator.generate()
}
}
printer.write(line: "#endif // #if arch(wasm32)")
return printer.contents
}
public func generateHost(context: SemanticsContext) throws -> String {
let printer = SourcePrinter(
header: """
import WasmKit
""")
let definitionMapping = GeneratedDefinitionMapping()
try TypeGenerator(context: context).generate(printer: printer)
for sourceFile in context.rootPackage.sourceFiles {
for case .world(let world) in sourceFile.items {
var generator = HostWorldGenerator(
printer: printer,
context: context,
world: world,
sourceFile: sourceFile,
packageUnit: context.rootPackage,
signatureTranslation: SignatureTranslation(
interfaceContext: nil
),
definitionMapping: definitionMapping
)
try generator.generate()
}
}
return printer.contents
}
public func generateGuestExportInterface(
context: SemanticsContext,
sourceFile: SyntaxNode<SourceFileSyntax>,
interface: SyntaxNode<InterfaceSyntax>,
sourceSummaryProvider: some SourceSummaryProvider
) throws -> String {
let printer = SourcePrinter(header: guestPrelude)
let mapping = SourceDefinitionMapping(sourceSummaryProvider: sourceSummaryProvider)
let typeResolver = {
try context.resolveType($0, in: interface, sourceFile: sourceFile, contextPackage: context.rootPackage)
}
for case .typeDef(let typeDef) in interface.items {
guard let swiftTypeName = sourceSummaryProvider.qualifiedSwiftTypeName(byWITName: typeDef.name.text) else {
continue
}
switch typeDef.body {
case .enum(let enumType):
guard let fieldNames = sourceSummaryProvider.enumCaseNames(byWITName: typeDef.name.text) else {
continue
}
try EnumWitRawValueGetter(
swiftTypeName: swiftTypeName,
fieldNames: fieldNames,
type: enumType
).print(printer: printer)
default: break
}
}
for case .function(let namedFunction) in interface.items {
let guestExport = GuestExportFunction(
function: namedFunction.function,
definitionMapping: mapping,
name: .interface(
context.rootPackage.packageName,
interfaceName: interface.name.text,
id: namedFunction.name.text
),
implementation: try ConvertCase.camelCase(namedFunction.name)
)
try guestExport.print(typeResolver: typeResolver, printer: printer)
}
printer.write(line: "#endif // #if arch(wasm32)")
return printer.contents
}
|
