Merge pull request #47 from rylev/wit-packages

Allow single file wit packages

Author: peterhuene

crates/wac-parser/src/ast/import.rs

@@ -118,7 +118,7 @@ impl<'a> Parse<'a> for ImportType<'a> {
     }
 }
 
-/// Represents a package path in the AST.
+/// AST representation of a path to an item such as a world in a package (e.g. `foo:bar/qux`).
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PackagePath<'a> {

crates/wac-parser/src/resolution/ast.rs

@@ -184,6 +184,7 @@ impl<'a> AstResolver<'a> {
         // If there's a target world in the directive, validate the composition
         // conforms to the target
         if let Some(path) = &self.document.directive.targets {
+            log::debug!("validating composition targets world `{}`", path.string);
             let item = self.resolve_package_export(&mut state, path)?;
             match item {
                 ItemKind::Type(Type::World(world)) => {
@@ -1563,6 +1564,7 @@ impl<'a> AstResolver<'a> {
         state: &mut State<'a>,
         path: &'a ast::PackagePath<'a>,
     ) -> ResolutionResult<ItemKind> {
+        log::debug!("resolving package export `{}`", path.string);
         // Check for reference to local item
         if path.name == self.document.directive.package.name {
             return self.resolve_local_export(state, path);

crates/wac-resolver/src/fs.rs

@@ -79,41 +79,46 @@ impl FileSystemPackageResolver {
             // First check to see if a directory exists.
             // If so, then treat it as a textual WIT package.
             #[cfg(feature = "wit")]
-            if path.is_dir() {
-                log::debug!(
-                    "loading WIT package from directory `{path}`",
-                    path = path.display()
-                );
-
+            {
+                let pkg_res_failure = |e| Error::PackageResolutionFailure {
+                    name: key.name.to_string(),
+                    span: *span,
+                    source: e,
+                };
                 let mut resolve = wit_parser::Resolve::new();
-                let (pkg, _) =
-                    resolve
-                        .push_dir(&path)
-                        .map_err(|e| Error::PackageResolutionFailure {
-                            name: key.name.to_string(),
-                            span: *span,
-                            source: e,
-                        })?;
-
-                packages.insert(
-                    *key,
-                    Arc::new(
-                        wit_component::encode(Some(true), &resolve, pkg)
-                            .with_context(|| {
-                                format!(
-                                    "failed to encode WIT package from directory `{path}`",
-                                    path = path.display()
-                                )
-                            })
-                            .map_err(|e| Error::PackageResolutionFailure {
-                                name: key.name.to_string(),
-                                span: *span,
-                                source: e,
-                            })?,
-                    ),
-                );
-
-                continue;
+                let pkg = if path.is_dir() {
+                    log::debug!(
+                        "loading WIT package from directory `{path}`",
+                        path = path.display()
+                    );
+
+                    let (pkg, _) = resolve.push_dir(&path).map_err(pkg_res_failure)?;
+                    Some(pkg)
+                } else if path.extension().and_then(std::ffi::OsStr::to_str) == Some("wit") {
+                    let unresolved = wit_parser::UnresolvedPackage::parse_file(&path)
+                        .map_err(pkg_res_failure)?;
+                    let pkg = resolve.push(unresolved).map_err(pkg_res_failure)?;
+                    Some(pkg)
+                } else {
+                    None
+                };
+                if let Some(pkg) = pkg {
+                    packages.insert(
+                        *key,
+                        Arc::new(
+                            wit_component::encode(Some(true), &resolve, pkg)
+                                .with_context(|| {
+                                    format!(
+                                        "failed to encode WIT package from `{path}`",
+                                        path = path.display()
+                                    )
+                                })
+                                .map_err(pkg_res_failure)?,
+                        ),
+                    );
+
+                    continue;
+                }
             }
 
             if !path.is_file() {