1use crate::{
2 Enum, Flags, Ident, Interface, InterfaceItem, Package, PackageName, Params, Record, Resource,
3 ResourceFunc, Result_, StandaloneFunc, Tuple, Type, TypeDef, TypeDefKind, Variant, World,
4 WorldItem,
5};
6use id_arena::Id;
7use wit_parser::PackageId;
8
9pub fn packages_from_parsed(resolve: &wit_parser::Resolve) -> Vec<Package> {
10 let converter = Converter::new(resolve);
11 converter.convert()
12}
13
14struct Converter<'a> {
15 resolve: &'a wit_parser::Resolve,
16}
17
18impl<'a> Converter<'a> {
19 fn new(resolve: &'a wit_parser::Resolve) -> Self {
20 Self { resolve }
21 }
22
23 fn convert(&self) -> Vec<Package> {
24 self.resolve
25 .packages
26 .iter()
27 .map(|(p_id, p)| self.convert_package(p_id, p))
28 .collect()
29 }
30
31 fn convert_package(&self, package_id: PackageId, package: &wit_parser::Package) -> Package {
32 let mut output = Package::new(self.convert_package_name(&package.name));
33 for (_, id) in &package.interfaces {
34 let interface = self.resolve.interfaces.get(*id).unwrap();
35 output.interface(self.convert_interface(
36 package_id,
37 interface,
38 None,
39 wit_parser::TypeOwner::Interface(*id),
40 ));
41 }
42 for (_, id) in &package.worlds {
43 let world = self.resolve.worlds.get(*id).unwrap();
44 output.world(self.convert_world(package_id, world, wit_parser::TypeOwner::World(*id)));
45 }
46 output
47 }
48
49 fn convert_package_name(&self, package: &wit_parser::PackageName) -> PackageName {
50 PackageName::new(
51 package.namespace.clone(),
52 package.name.clone(),
53 package.version.clone(),
54 )
55 }
56
57 fn convert_world(
58 &self,
59 package_id: PackageId,
60 world: &wit_parser::World,
61 owner: wit_parser::TypeOwner,
62 ) -> World {
63 let mut output = World::new(world.name.clone());
64
65 for (key, item) in &world.imports {
66 match item {
67 wit_parser::WorldItem::Interface { id, .. } => {
68 let interface = self.resolve.interfaces.get(*id).unwrap();
69 let ident = self.interface_ident(package_id, Some(key), interface);
70
71 if interface.name.is_some() {
72 output.item(WorldItem::named_interface_import(ident))
73 } else {
74 output.item(WorldItem::inline_interface_import(self.convert_interface(
75 package_id,
76 interface,
77 Some(ident),
78 owner,
79 )))
80 }
81 }
82 wit_parser::WorldItem::Function(func) => {
83 if let Some(func) = self.standalone_func_convert(func) {
84 output.item(WorldItem::function_import(func));
85 }
86 }
87 wit_parser::WorldItem::Type(type_id) => {
88 let (target, item, rename) = self.convert_world_item_type(package_id, *type_id);
89 output.use_type(target, item, rename)
90 }
91 }
92 }
93
94 for (key, item) in &world.exports {
95 match item {
96 wit_parser::WorldItem::Interface { id, .. } => {
97 let interface = self.resolve.interfaces.get(*id).unwrap();
98 let ident = self.interface_ident(package_id, Some(key), interface);
99 if interface.name.is_some() {
100 output.item(WorldItem::named_interface_export(ident));
101 } else {
102 output.item(WorldItem::inline_interface_export(self.convert_interface(
103 package_id,
104 interface,
105 Some(ident),
106 owner,
107 )));
108 }
109 }
110 wit_parser::WorldItem::Function(func) => {
111 if let Some(func) = self.standalone_func_convert(func) {
112 output.item(WorldItem::function_export(func));
113 }
114 }
115 wit_parser::WorldItem::Type(type_id) => {
116 let (target, item, rename) = self.convert_world_item_type(package_id, *type_id);
117 output.use_type(target, item, rename)
118 }
119 }
120 }
121
122 output.uses_mut().sort();
123 output.items_mut().sort();
124
125 output
126 }
127
128 fn convert_world_item_type(
129 &self,
130 package_id: PackageId,
131 type_id: wit_parser::TypeId,
132 ) -> (Ident, Ident, Option<Ident>) {
133 let type_def = self.resolve.types.get(type_id).unwrap();
134 let underlying_type_def = self.underlying_type_def(&type_def);
135 let interface_ident = self
136 .type_def_owner_interface_ident(package_id, underlying_type_def)
137 .expect("Type not part of an interface");
138 let local_type_name = type_def.name.clone().unwrap();
139 let underlying_local_type_name = underlying_type_def.name.clone().unwrap();
140 if underlying_local_type_name == local_type_name {
141 (interface_ident, local_type_name.into(), None)
142 } else {
143 (
144 interface_ident,
145 underlying_local_type_name.into(),
146 Some(local_type_name.into()),
147 )
148 }
149 }
150
151 fn convert_interface(
152 &self,
153 package_id: PackageId,
154 interface: &wit_parser::Interface,
155 inlined_name: Option<Ident>,
156 owner: wit_parser::TypeOwner,
157 ) -> Interface {
158 let mut output =
159 Interface::new(interface.name.clone().map(Ident::new).unwrap_or_else(|| {
160 inlined_name
161 .clone()
162 .expect("inlined interface must pass in inlined_name")
163 }));
164
165 for (_, func) in &interface.functions {
166 if let Some(func) = self.standalone_func_convert(func) {
167 output.items.push(InterfaceItem::Function(func));
168 }
169 }
170 for (_, type_id) in &interface.types {
171 let type_def = self.resolve.types.get(*type_id).unwrap();
172 let underlying_type_def = self.underlying_type_def(&type_def);
173
174 if underlying_type_def.owner == owner {
175 if let Some(type_def) = self.convert_type_def(type_def, *type_id) {
176 output.item(InterfaceItem::TypeDef(type_def));
177 }
178 } else {
179 let interface_ident = self
180 .type_def_owner_interface_ident(package_id, underlying_type_def)
181 .expect("Type not part of an interface");
182 let local_type_name = type_def.name.clone().unwrap();
183 let underlying_local_type_name = underlying_type_def.name.clone().unwrap();
184 if underlying_local_type_name == local_type_name {
185 output.use_type(interface_ident, local_type_name, None);
186 } else {
187 output.use_type(
188 interface_ident,
189 underlying_local_type_name,
190 Some(local_type_name.into()),
191 );
192 }
193 }
194 }
195
196 output.uses_mut().sort();
197 output.items_mut().sort();
198
199 output
200 }
201
202 fn convert_type_def(
203 &self,
204 type_def: &wit_parser::TypeDef,
205 type_def_id: Id<wit_parser::TypeDef>,
206 ) -> Option<TypeDef> {
207 match &type_def.name {
208 None => None,
209 Some(name) => {
210 let kind = match &type_def.kind {
211 wit_parser::TypeDefKind::Record(record) => {
212 let output = self.convert_record(record);
213 TypeDefKind::Record(output)
214 }
215 wit_parser::TypeDefKind::Resource => {
216 let output = self.convert_resource(type_def_id, name, &type_def.owner);
217 TypeDefKind::Resource(output)
218 }
219 wit_parser::TypeDefKind::Flags(flags) => {
220 let output = self.convert_flags(flags);
221 TypeDefKind::Flags(output)
222 }
223 wit_parser::TypeDefKind::Variant(variant) => {
224 let output = self.convert_variant(variant);
225 TypeDefKind::Variant(output)
226 }
227 wit_parser::TypeDefKind::Enum(enum_) => {
228 let output = self.convert_enum(enum_);
229 TypeDefKind::Enum(output)
230 }
231 wit_parser::TypeDefKind::Future(ty) => {
232 TypeDefKind::Type(Type::future(self.convert_option_type(ty)))
233 }
234 wit_parser::TypeDefKind::Stream(ty) => {
235 TypeDefKind::Type(Type::stream(self.convert_option_type(ty)))
236 }
237 wit_parser::TypeDefKind::ErrorContext => TypeDefKind::Type(Type::ErrorContext),
238 wit_parser::TypeDefKind::Option(ty) => {
240 let output = Type::option(self.convert_type(ty));
241 TypeDefKind::Type(output)
242 }
243 wit_parser::TypeDefKind::List(ty) => {
244 let output = Type::list(self.convert_type(ty));
245 TypeDefKind::Type(output)
246 }
247 wit_parser::TypeDefKind::Handle(handle) => {
248 let output = self.handle_to_type(handle);
249 TypeDefKind::Type(output)
250 }
251 wit_parser::TypeDefKind::Result(result) => {
252 let output = Type::result(self.convert_result(result));
253 TypeDefKind::Type(output)
254 }
255 wit_parser::TypeDefKind::Tuple(tuple) => {
256 let output = Type::Tuple(self.convert_tuple(tuple));
257 TypeDefKind::Type(output)
258 }
259 wit_parser::TypeDefKind::Type(ty) => {
260 let output = self.convert_type(ty);
261 TypeDefKind::Type(output)
262 }
263 wit_parser::TypeDefKind::Unknown => unreachable!(),
264 };
265
266 Some(TypeDef::new(name.clone(), kind))
267 }
268 }
269 }
270
271 fn convert_option_type(&self, ty: &Option<wit_parser::Type>) -> Option<Type> {
272 ty.as_ref().map(|ty| self.convert_type(ty))
273 }
274
275 fn convert_type(&self, type_: &wit_parser::Type) -> Type {
276 match type_ {
277 wit_parser::Type::Bool => Type::Bool,
278 wit_parser::Type::U8 => Type::U8,
279 wit_parser::Type::U16 => Type::U16,
280 wit_parser::Type::U32 => Type::U32,
281 wit_parser::Type::U64 => Type::U64,
282 wit_parser::Type::S8 => Type::S8,
283 wit_parser::Type::S16 => Type::S16,
284 wit_parser::Type::S32 => Type::S32,
285 wit_parser::Type::S64 => Type::S64,
286 wit_parser::Type::F32 => Type::F32,
287 wit_parser::Type::F64 => Type::F64,
288 wit_parser::Type::Char => Type::Char,
289 wit_parser::Type::String => Type::String,
290 wit_parser::Type::Id(id) => {
291 let type_def = self.resolve.types.get(*id).expect("Type not found");
292 match &type_def.name {
293 Some(name) => Type::named(name.clone()),
294 None => match &type_def.kind {
295 wit_parser::TypeDefKind::Tuple(tuple) => {
296 Type::Tuple(self.convert_tuple(tuple))
297 }
298 wit_parser::TypeDefKind::Option(type_) => {
299 Type::option(self.convert_type(type_))
300 }
301 wit_parser::TypeDefKind::Result(result) => {
302 Type::result(self.convert_result(result))
303 }
304 wit_parser::TypeDefKind::List(type_) => {
305 Type::list(self.convert_type(type_))
306 }
307 wit_parser::TypeDefKind::Handle(handle) => self.handle_to_type(handle),
308 wit_parser::TypeDefKind::Future(type_) => {
309 Type::future(self.convert_option_type(type_))
310 }
311 wit_parser::TypeDefKind::Stream(type_) => {
312 Type::stream(self.convert_option_type(type_))
313 }
314 wit_parser::TypeDefKind::ErrorContext => Type::ErrorContext,
315 wit_parser::TypeDefKind::Record(_)
316 | wit_parser::TypeDefKind::Resource
317 | wit_parser::TypeDefKind::Flags(_)
318 | wit_parser::TypeDefKind::Variant(_)
319 | wit_parser::TypeDefKind::Enum(_)
320 | wit_parser::TypeDefKind::Type(_) => {
321 panic!("type doesn't have a name, and can't be inlined")
322 }
323 wit_parser::TypeDefKind::Unknown => unreachable!(),
324 },
325 }
326 }
327 }
328 }
329
330 fn convert_enum(&self, enum_: &wit_parser::Enum) -> Enum {
331 let mut output = Enum::empty();
332 for case in &enum_.cases {
333 output.case(case.name.clone())
334 }
335 output
336 }
337 fn convert_record(&self, record: &wit_parser::Record) -> Record {
338 Record::new(record.fields.iter().map(|field| {
339 let name = field.name.clone();
340 let type_ = self.convert_type(&field.ty);
341 (name, type_)
342 }))
343 }
344 fn convert_variant(&self, variant: &wit_parser::Variant) -> Variant {
345 let mut output = Variant::empty();
346 for case in &variant.cases {
347 match &case.ty {
348 Some(ty) => {
349 let ty = self.convert_type(ty);
350 output.case((case.name.clone(), ty))
351 }
352 None => output.case((case.name.clone(),)),
353 }
354 }
355 output
356 }
357 fn convert_flags(&self, flags: &wit_parser::Flags) -> Flags {
358 Flags::new(flags.flags.iter().map(|flag| (flag.name.clone(),)))
359 }
360
361 fn convert_resource(
362 &self,
363 resource_id: Id<wit_parser::TypeDef>,
364 name: &str,
365 owner: &wit_parser::TypeOwner,
366 ) -> Resource {
367 let functions = match owner {
368 wit_parser::TypeOwner::World(_) => {
369 todo!("Enable once win-encoder supports `include`")
370 }
371 wit_parser::TypeOwner::Interface(id) => {
372 &self.resolve.interfaces.get(*id).unwrap().functions
373 }
374 wit_parser::TypeOwner::None => panic!("Resource has to have an owner"),
375 };
376
377 let mut output = Resource::empty();
378 for (_, func) in functions {
379 if let Some(method) = self.convert_resource_func(resource_id, name, func) {
380 output.func(method);
381 }
382 }
383 output
384 }
385
386 fn convert_resource_func(
387 &self,
388 resource_id: Id<wit_parser::TypeDef>,
389 resource_name: &str,
390 func: &wit_parser::Function,
391 ) -> Option<ResourceFunc> {
392 let mut skip_first_param = false;
394 let mut with_returns = true;
396 let mut method = match func.kind {
397 wit_parser::FunctionKind::Freestanding => return None,
398 wit_parser::FunctionKind::Method(id) => {
399 if id != resource_id {
400 return None;
401 }
402 skip_first_param = true;
403 let name = clean_func_name(resource_name, &func.name);
404 ResourceFunc::method(name)
405 }
406 wit_parser::FunctionKind::Static(id) => {
407 if id != resource_id {
408 return None;
409 }
410 let name = clean_func_name(resource_name, &func.name);
411 ResourceFunc::static_(name)
412 }
413 wit_parser::FunctionKind::Constructor(id) => {
414 if id != resource_id {
415 return None;
416 }
417 with_returns = false;
418 ResourceFunc::constructor()
419 }
420 };
421
422 method.set_params(self.convert_params(&func.params));
423 if skip_first_param {
424 method.params_mut().items_mut().remove(0);
425 }
426
427 if with_returns {
428 method.set_result(func.result.as_ref().map(|ty| self.convert_type(ty)));
429 }
430
431 Some(method)
432 }
433
434 fn standalone_func_convert(&self, func: &wit_parser::Function) -> Option<StandaloneFunc> {
435 match func.kind {
436 wit_parser::FunctionKind::Method(_)
437 | wit_parser::FunctionKind::Static(_)
438 | wit_parser::FunctionKind::Constructor(_) => None,
439 wit_parser::FunctionKind::Freestanding => {
440 let mut output = StandaloneFunc::new(func.name.clone());
441
442 output.set_params(self.convert_params(&func.params));
443 output.set_result(func.result.map(|ty| self.convert_type(&ty)));
444
445 Some(output)
446 }
447 }
448 }
449
450 fn convert_params(&self, params: &[(String, wit_parser::Type)]) -> Params {
451 let mut output = Params::empty();
452 for (name, ty) in params.iter() {
453 let name = name.to_string();
454 let ty = self.convert_type(ty);
455 output.push(name, ty);
456 }
457 output
458 }
459
460 fn handle_to_type(&self, handle: &wit_parser::Handle) -> Type {
461 let id = match handle {
462 wit_parser::Handle::Own(id) => id,
463 wit_parser::Handle::Borrow(id) => id,
464 };
465 let type_def = self.resolve.types.get(*id).expect("Type not found");
466 let name = type_def
467 .name
468 .clone()
469 .expect("Handles should only be for resources, and resources should have names");
470 match handle {
471 wit_parser::Handle::Own(_) => Type::named(name),
472 wit_parser::Handle::Borrow(_) => Type::borrow(name),
473 }
474 }
475
476 fn convert_result(&self, result: &wit_parser::Result_) -> Result_ {
477 match (&result.ok, &result.err) {
478 (None, None) => Result_::empty(),
479 (Some(ok), None) => Result_::ok(self.convert_type(ok)),
480 (None, Some(err)) => Result_::err(self.convert_type(err)),
481 (Some(ok), Some(err)) => Result_::both(self.convert_type(ok), self.convert_type(err)),
482 }
483 }
484
485 fn convert_tuple(&self, tuple: &wit_parser::Tuple) -> Tuple {
486 let mut output = Tuple::empty();
487 for ty in tuple.types.iter() {
488 output.types_mut().push(self.convert_type(ty));
489 }
490 output
491 }
492
493 fn interface_ident(
494 &self,
495 package_id: PackageId,
496 world_key: Option<&wit_parser::WorldKey>,
497 interface: &wit_parser::Interface,
498 ) -> Ident {
499 match &interface.name {
500 Some(name) => {
501 if interface.package == Some(package_id) {
503 Ident::new(name.clone())
504 } else {
505 let package = interface
506 .package
507 .map(|package_id| self.resolve.packages.get(package_id).unwrap());
508
509 match package {
510 Some(package) => Ident::new(format!(
511 "{}:{}/{}{}",
512 package.name.namespace,
513 package.name.name,
514 name,
515 package
516 .name
517 .version
518 .as_ref()
519 .map(|version| format!("@{}", version))
520 .unwrap_or_else(|| "".to_string())
521 )),
522 None => Ident::new(name.clone()),
523 }
524 }
525 }
526 None => match world_key {
527 Some(world_key) => match world_key {
528 wit_parser::WorldKey::Name(name) => Ident::new(name.clone()),
529 wit_parser::WorldKey::Interface(_) => {
530 unreachable!("inlined interface must have a world key name")
531 }
532 },
533 None => panic!("inlined interface requires a world key"),
534 },
535 }
536 }
537
538 fn underlying_type_def(&'a self, type_def: &'a wit_parser::TypeDef) -> &'a wit_parser::TypeDef {
539 match &type_def.kind {
540 wit_parser::TypeDefKind::Type(type_) => match &type_ {
541 wit_parser::Type::Id(type_id) => {
542 let type_def = self.resolve.types.get(*type_id).unwrap();
543 type_def
544 }
545 _ => type_def,
546 },
547 _ => type_def,
548 }
549 }
550
551 fn type_def_owner_interface_ident(
552 &self,
553 package_id: PackageId,
554 type_def: &wit_parser::TypeDef,
555 ) -> Option<Ident> {
556 if let wit_parser::TypeOwner::Interface(id) = type_def.owner {
557 Some(self.interface_ident(package_id, None, self.resolve.interfaces.get(id).unwrap()))
558 } else {
559 None
560 }
561 }
562}
563
564fn clean_func_name(resource_name: &str, method_name: &str) -> String {
565 const METHOD_PREFIX: &str = "[method]";
566 const STATIC_PREFIX: &str = "[static]";
567
568 let method_name = method_name
569 .strip_prefix(METHOD_PREFIX)
570 .unwrap_or(method_name);
571 let method_name = method_name
572 .strip_prefix(STATIC_PREFIX)
573 .unwrap_or(method_name);
574 let method_name = method_name.strip_prefix(resource_name).unwrap();
575 let method_name = method_name.strip_prefix(".").unwrap();
576 method_name.to_string()
577}