Skip to content

Commit af8879c

Browse files
macovedjmacovedj
committed
init
1 parent 1e537ed commit af8879c

File tree

7 files changed

+210
-8
lines changed

7 files changed

+210
-8
lines changed

‎crates/wit-component/src/printing.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ impl WitPrinter {
6969
}
7070

7171
if has_multiple_packages {
72-
self.output.push_str("{");
72+
self.output.push_str("{\n");
7373
self.output.indent += 1
7474
} else {
7575
self.print_semicolon();

‎crates/wit-parser/src/ast.rs‎

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -220,6 +220,19 @@ impl<'a> DeclList<'a> {
220220
}
221221
Ok(())
222222
}
223+
224+
fn for_each_nest<'b>(&'b self, mut f: impl FnMut(&'b Nest<'a>) -> Result<()>) -> Result<()> {
225+
for item in self.items.iter() {
226+
if let AstItem::Interface(i) = item {
227+
for item in i.items.iter() {
228+
if let InterfaceItem::Nest(n) = item {
229+
f(n)?;
230+
}
231+
}
232+
}
233+
}
234+
Ok(())
235+
}
223236
}
224237

225238
enum AstItem<'a> {
@@ -545,6 +558,42 @@ enum InterfaceItem<'a> {
545558
TypeDef(TypeDef<'a>),
546559
Func(NamedFunc<'a>),
547560
Use(Use<'a>),
561+
Nest(Nest<'a>),
562+
}
563+
564+
struct Nest<'a> {
565+
id: PackageName<'a>,
566+
name: Id<'a>,
567+
attributes: Vec<Attribute<'a>>,
568+
}
569+
570+
impl<'a> Nest<'a> {
571+
fn parse(tokens: &mut Tokenizer<'a>, attributes: Vec<Attribute<'a>>) -> Result<Self> {
572+
tokens.eat(Token::Nest)?;
573+
let id = parse_id(tokens)?;
574+
tokens.expect(Token::Colon)?;
575+
// `foo:bar/[email protected]`
576+
let namespace = id;
577+
let pkg_name = parse_id(tokens)?;
578+
tokens.expect(Token::Slash)?;
579+
let name = parse_id(tokens)?;
580+
let version = parse_opt_version(tokens)?;
581+
tokens.expect_semicolon()?;
582+
Ok(Self {
583+
id: PackageName {
584+
docs: Default::default(),
585+
span: Span {
586+
start: namespace.span.start,
587+
end: pkg_name.span.end,
588+
},
589+
namespace,
590+
name: pkg_name,
591+
version,
592+
},
593+
name,
594+
attributes,
595+
})
596+
}
548597
}
549598

550599
struct Use<'a> {
@@ -983,6 +1032,7 @@ impl<'a> InterfaceItem<'a> {
9831032
NamedFunc::parse(tokens, docs, attributes).map(InterfaceItem::Func)
9841033
}
9851034
Some((_span, Token::Use)) => Use::parse(tokens, attributes).map(InterfaceItem::Use),
1035+
Some((_span, Token::Nest)) => Nest::parse(tokens, attributes).map(InterfaceItem::Nest),
9861036
other => Err(err_expected(tokens, "`type`, `resource` or `func`", other).into()),
9871037
}
9881038
}

‎crates/wit-parser/src/ast/lex.rs‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,7 @@ pub enum Token {
8484
As,
8585
From_,
8686
Static,
87+
Nest,
8788
Interface,
8889
Tuple,
8990
Import,
@@ -315,6 +316,7 @@ impl<'a> Tokenizer<'a> {
315316
"as" => As,
316317
"from" => From_,
317318
"static" => Static,
319+
"nest" => Nest,
318320
"interface" => Interface,
319321
"tuple" => Tuple,
320322
"world" => World,
@@ -576,6 +578,7 @@ impl Token {
576578
As => "keyword `as`",
577579
From_ => "keyword `from`",
578580
Static => "keyword `static`",
581+
Nest => "keyword `nest`",
579582
Interface => "keyword `interface`",
580583
Tuple => "keyword `tuple`",
581584
Import => "keyword `import`",

‎crates/wit-parser/src/ast/resolve.rs‎

Lines changed: 150 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,12 @@
1-
use super::{ParamList, ResultList, WorldOrInterface};
1+
use super::{
2+
// AstItem as RootAstItem, Interface as RootInterface,
3+
Nest,
4+
ParamList,
5+
ResultList,
6+
WorldOrInterface,
7+
};
28
use crate::ast::toposort::toposort;
9+
use crate::ast::InterfaceItem;
310
use crate::*;
411
use anyhow::bail;
512
use std::collections::{HashMap, HashSet};
@@ -100,9 +107,11 @@ enum Key {
100107

101108
enum TypeItem<'a, 'b> {
102109
Use(&'b ast::Use<'a>),
110+
Nest(&'b ast::Nest<'a>),
103111
Def(&'b ast::TypeDef<'a>),
104112
}
105113

114+
#[derive(Debug)]
106115
enum TypeOrItem {
107116
Type(TypeId),
108117
Item(&'static str),
@@ -174,6 +183,15 @@ impl<'a> Resolver<'a> {
174183
for item in decl_list.items.iter() {
175184
match item {
176185
ast::AstItem::Interface(iface) => {
186+
for item in &iface.items {
187+
if let InterfaceItem::Nest(n) = item {
188+
let id = match self.ast_items[i][n.name.name] {
189+
AstItem::Interface(id) => id,
190+
AstItem::World(_) => unreachable!(),
191+
};
192+
iface_id_to_ast.insert(id, (iface, i));
193+
}
194+
}
177195
let id = match self.ast_items[i][iface.name.name] {
178196
AstItem::Interface(id) => id,
179197
AstItem::World(_) => unreachable!(),
@@ -292,6 +310,30 @@ impl<'a> Resolver<'a> {
292310
Ok(())
293311
})
294312
.unwrap();
313+
decl_list
314+
.for_each_nest(|nest: &Nest| {
315+
let deps = foreign_deps
316+
.entry(nest.id.package_name())
317+
.or_insert_with(|| {
318+
self.foreign_dep_spans.push(nest.id.span);
319+
IndexMap::new()
320+
});
321+
let id = *deps.entry(nest.name.name).or_insert_with(|| {
322+
log::trace!(
323+
"creating an interface for foreign dep: {}/{}",
324+
nest.id.package_name(),
325+
nest.name.name
326+
);
327+
328+
AstItem::Interface(self.alloc_interface(nest.name.span))
329+
});
330+
match id {
331+
AstItem::Interface(id) => foreign_interfaces.insert(id),
332+
AstItem::World(_) => unreachable!(),
333+
};
334+
Ok(())
335+
})
336+
.unwrap();
295337
}
296338
self.foreign_deps = foreign_deps;
297339
self.foreign_interfaces = foreign_interfaces;
@@ -306,6 +348,7 @@ impl<'a> Resolver<'a> {
306348
});
307349
self.interfaces.alloc(Interface {
308350
name: None,
351+
nested: IndexMap::new(),
309352
types: IndexMap::new(),
310353
docs: Docs::default(),
311354
stability: Default::default(),
@@ -364,6 +407,28 @@ impl<'a> Resolver<'a> {
364407
assert!(prev.is_none());
365408
let prev = names.insert(i.name.name, item);
366409
assert!(prev.is_none());
410+
for nestitem in i.items.iter() {
411+
if let InterfaceItem::Nest(n) = nestitem {
412+
if package_items.insert(n.name.name, n.name.span).is_some() {
413+
bail!(Error::new(
414+
n.name.span,
415+
format!("duplicate item named `{}`", n.name.name),
416+
))
417+
}
418+
let prev = decl_list_ns.insert(n.name.name, ());
419+
assert!(prev.is_none());
420+
let prev = order.insert(n.name.name, Vec::new());
421+
assert!(prev.is_none());
422+
// let i = RootAstItem::Interface(RootInterface {
423+
// docs: Default::default(),
424+
// attributes: vec![],
425+
// name: n.name.clone(),
426+
// items: vec![],
427+
// });
428+
// let prev = names.insert(n.name.name, &i);
429+
// assert!(prev.is_none());
430+
}
431+
}
367432
}
368433
ast::AstItem::World(w) => {
369434
if package_items.insert(w.name.name, w.name.span).is_some() {
@@ -380,7 +445,7 @@ impl<'a> Resolver<'a> {
380445
assert!(prev.is_none());
381446
}
382447
// These are processed down below.
383-
ast::AstItem::Use(_) => {}
448+
ast::AstItem::Use(_) => {} // ast::AstItem::Nest(_) => todo!(),
384449
}
385450
}
386451
decl_list_namespaces.push(decl_list_ns);
@@ -458,6 +523,29 @@ impl<'a> Resolver<'a> {
458523
}
459524
Ok(())
460525
})?;
526+
decl_list.for_each_nest(|nest: &Nest| {
527+
match decl_list_ns.get(nest.name.name) {
528+
Some((_, ItemSource::Foreign)) => return Ok(()),
529+
Some((_, ItemSource::Local(id))) => {
530+
order[nest.name.name].push(id.clone());
531+
}
532+
None => match package_items.get(nest.name.name) {
533+
Some(_) => {
534+
// order[nest.name.name].push(nest.name.clone());
535+
}
536+
None => {
537+
bail!(Error::new(
538+
nest.name.span,
539+
format!(
540+
"interface or world `{name}` not found in package",
541+
name = nest.name.name
542+
),
543+
))
544+
}
545+
},
546+
}
547+
Ok(())
548+
})?;
461549
}
462550

463551
let order = toposort("interface or world", &order)?;
@@ -470,22 +558,32 @@ impl<'a> Resolver<'a> {
470558
let mut iface_id_order = Vec::new();
471559
let mut world_id_order = Vec::new();
472560
for name in order {
473-
match names.get(name).unwrap() {
474-
ast::AstItem::Interface(_) => {
561+
match names.get(name) {
562+
Some(ast::AstItem::Interface(i)) => {
563+
for item in &i.items {
564+
if let InterfaceItem::Nest(n) = item {
565+
let id = self.alloc_interface(package_items[name]);
566+
self.interfaces[id].name = Some(name.to_string());
567+
let prev = ids.insert(n.name.name, AstItem::Interface(id));
568+
assert!(prev.is_none());
569+
iface_id_order.push(id);
570+
}
571+
}
475572
let id = self.alloc_interface(package_items[name]);
476573
self.interfaces[id].name = Some(name.to_string());
477574
let prev = ids.insert(name, AstItem::Interface(id));
478575
assert!(prev.is_none());
479576
iface_id_order.push(id);
480577
}
481-
ast::AstItem::World(_) => {
578+
Some(ast::AstItem::World(_)) => {
482579
let id = self.alloc_world(package_items[name]);
483580
self.worlds[id].name = name.to_string();
484581
let prev = ids.insert(name, AstItem::World(id));
485582
assert!(prev.is_none());
486583
world_id_order.push(id);
487584
}
488-
ast::AstItem::Use(_) => unreachable!(),
585+
Some(ast::AstItem::Use(_)) => unreachable!(),
586+
None => {}
489587
};
490588
}
491589
for decl_list in decl_lists {
@@ -517,6 +615,15 @@ impl<'a> Resolver<'a> {
517615
(name.name, item)
518616
}
519617
ast::AstItem::Interface(i) => {
618+
for item in &i.items {
619+
if let InterfaceItem::Nest(n) = item {
620+
let iface_item = ids[n.name.name];
621+
let prev = items.insert(n.name.name, iface_item);
622+
assert!(prev.is_none());
623+
let prev = self.package_items.insert(n.name.name, iface_item);
624+
assert!(prev.is_none());
625+
}
626+
}
520627
let iface_item = ids[i.name.name];
521628
assert!(matches!(iface_item, AstItem::Interface(_)));
522629
(i.name.name, iface_item)
@@ -587,6 +694,12 @@ impl<'a> Resolver<'a> {
587694

588695
Ok(())
589696
})?;
697+
decl_list.for_each_nest(|nest| {
698+
let (item, name, span) = self.resolve_ast_item_nest(nest)?;
699+
let iface = self.extract_iface_from_item(&item, &name, span)?;
700+
let lookup = &mut self.interface_types[iface.index()];
701+
Ok(())
702+
})?;
590703
}
591704
Ok(())
592705
}
@@ -784,6 +897,7 @@ impl<'a> Resolver<'a> {
784897
ast::InterfaceItem::Use(u) => Some(TypeItem::Use(u)),
785898
ast::InterfaceItem::TypeDef(t) => Some(TypeItem::Def(t)),
786899
ast::InterfaceItem::Func(_) => None,
900+
ast::InterfaceItem::Nest(n) => Some(TypeItem::Nest(n)),
787901
}),
788902
)?;
789903

@@ -830,6 +944,7 @@ impl<'a> Resolver<'a> {
830944
}
831945
}
832946
ast::InterfaceItem::TypeDef(_) => {}
947+
ast::InterfaceItem::Nest(_) => {}
833948
}
834949
}
835950
for func in funcs {
@@ -861,6 +976,9 @@ impl<'a> Resolver<'a> {
861976
TypeItem::Use(u) => {
862977
self.resolve_use(owner, u)?;
863978
}
979+
TypeItem::Nest(n) => {
980+
self.resolve_nest(owner, n)?;
981+
}
864982
TypeItem::Def(_) => {}
865983
}
866984
}
@@ -892,6 +1010,7 @@ impl<'a> Resolver<'a> {
8921010
type_defs.insert(name.name, None);
8931011
}
8941012
}
1013+
TypeItem::Nest(n) => {}
8951014
}
8961015
}
8971016
let order = toposort("type", &type_deps)?;
@@ -950,6 +1069,16 @@ impl<'a> Resolver<'a> {
9501069
Ok(())
9511070
}
9521071

1072+
fn resolve_nest(&mut self, owner: TypeOwner, n: &ast::Nest<'a>) -> Result<()> {
1073+
let (item, name, span) = self.resolve_ast_item_nest(&n)?;
1074+
let use_from = self.extract_iface_from_item(&item, &name, span)?;
1075+
let extracted = &self.interfaces[use_from];
1076+
1077+
let stability = self.stability(&n.attributes)?;
1078+
let lookup = &self.interface_types[use_from.index()];
1079+
Ok(())
1080+
}
1081+
9531082
/// For each name in the `include`, resolve the path of the include, add it to the self.includes
9541083
fn resolve_include(&mut self, world_id: WorldId, i: &ast::Include<'a>) -> Result<()> {
9551084
let stability = self.stability(&i.attributes)?;
@@ -1051,6 +1180,21 @@ impl<'a> Resolver<'a> {
10511180
}
10521181
}
10531182

1183+
fn resolve_ast_item_nest(&self, nest: &ast::Nest<'a>) -> Result<(AstItem, String, Span)> {
1184+
let item: Option<&AstItem> = self.ast_items[self.cur_ast_index]
1185+
.get(nest.name.name)
1186+
.or_else(|| self.package_items.get(nest.name.name));
1187+
match item {
1188+
Some(item) => Ok((*item, nest.name.name.to_string(), nest.id.span)),
1189+
None => {
1190+
bail!(Error::new(
1191+
nest.id.span,
1192+
format!("interface or world `{}` does not exist", nest.name.name),
1193+
))
1194+
}
1195+
}
1196+
}
1197+
10541198
fn extract_iface_from_item(
10551199
&self,
10561200
item: &AstItem,

0 commit comments

Comments
 (0)