Add stability attributes to the worlds (bytecodealliance#2194)

Signed-off-by: James Sturtevant <[email protected]>

Author: jsturtevant

crates/wit-smith/src/generate.rs

@@ -30,6 +30,7 @@ struct InterfaceGenerator<'a> {
     unique_names: HashSet<String>,
     types_in_interface: Vec<Type>,
     package_name: &'a str,
+    version: Option<Version>,
 }
 
 #[derive(Clone)]
@@ -147,7 +148,7 @@ impl Generator {
             name: PackageName {
                 namespace,
                 name: package_name.clone(),
-                version,
+                version: version.clone(),
             },
             file: File::default(),
             sources: SourceMap::new(),
@@ -195,7 +196,8 @@ impl Generator {
                     let world_name =
                         file.gen_unique_package_name(u, &mut package_names, DefinitionKind::World)?;
                     log::debug!("new world `{world_name}` in {i}");
-                    let world = self.gen_world(u, &world_name, file, &package_name)?;
+                    let world =
+                        self.gen_world(u, &world_name, file, &package_name, version.clone())?;
                     file.items.push(world);
 
                     // Insert the world at the package and file level, asserting
@@ -227,7 +229,7 @@ impl Generator {
                     let id = self.next_interface_id;
                     self.next_interface_id += 1;
                     let (src, types) =
-                        self.gen_interface(u, Some(&name), file, &package_name, None)?;
+                        self.gen_interface(u, Some(&name), file, &package_name, None, None)?;
                     file.items.push(src);
                     if types.is_empty() {
                         continue;
@@ -352,8 +354,9 @@ impl Generator {
         name: &str,
         file: &mut File,
         package_name: &str,
+        version: Option<Version>,
     ) -> Result<String> {
-        InterfaceGenerator::new(self, file, package_name).gen_world(u, name)
+        InterfaceGenerator::new(self, file, package_name, version).gen_world(u, name)
     }
 
     fn gen_interface(
@@ -363,8 +366,9 @@ impl Generator {
         file: &mut File,
         package_name: &str,
         world_name: Option<&str>,
+        version: Option<Version>,
     ) -> Result<(String, Vec<Type>)> {
-        let mut generator = InterfaceGenerator::new(self, file, package_name);
+        let mut generator = InterfaceGenerator::new(self, file, package_name, version);
         let ret = generator.gen_interface(u, name, world_name)?;
         Ok((ret, generator.types_in_interface))
     }
@@ -495,6 +499,7 @@ impl<'a> InterfaceGenerator<'a> {
         generator: &'a mut Generator,
         file: &'a mut File,
         package_name: &'a str,
+        version: Option<Version>,
     ) -> InterfaceGenerator<'a> {
         InterfaceGenerator {
             generator,
@@ -504,6 +509,48 @@ impl<'a> InterfaceGenerator<'a> {
             // ABI always using a linear memory named `memory`.
             unique_names: HashSet::from_iter(["memory".to_string()]),
             package_name: package_name,
+            version,
+        }
+    }
+
+    // Generate a feature gate annotation (@since, @unstable, or @deprecated)
+    // If version is provided, ensures the annotation is compatible with the version
+    fn gen_feature_annotation(&self, u: &mut Unstructured<'_>) -> Result<Option<String>> {
+        if u.arbitrary()? {
+            return Ok(None);
+        }
+
+        let feature_names = ["active", "inactive"];
+        #[derive(Arbitrary)]
+        enum AnnotationType {
+            Since,
+            Unstable,
+            Deprecated,
+        }
+
+        match self.version {
+            None => {
+                // No package version available
+                return Ok(None);
+            }
+            Some(_) => match u.arbitrary()? {
+                AnnotationType::Since => {
+                    let v = gen_version_less_than(u, &self.version)?;
+                    Ok(Some(format!("@since(version = {v})")))
+                }
+                AnnotationType::Unstable => {
+                    let feature = u.choose(&feature_names)?;
+                    Ok(Some(format!("@unstable(feature = {feature})")))
+                }
+                AnnotationType::Deprecated => {
+                    let depreciation_version = gen_version_less_than(u, &self.version)?;
+                    let since_version =
+                        gen_version_less_than(u, &Some(depreciation_version.clone()))?;
+                    Ok(Some(format!(
+                        "@deprecated(version = {depreciation_version})\n@since(version = {since_version})",
+                    )))
+                }
+            },
         }
     }
 
@@ -514,6 +561,12 @@ impl<'a> InterfaceGenerator<'a> {
         world_name: Option<&str>,
     ) -> Result<String> {
         let mut ret = String::new();
+
+        if let Some(annotation) = self.gen_feature_annotation(u)? {
+            ret.push_str(&annotation);
+            ret.push_str("\n");
+        }
+
         ret.push_str("interface ");
         if let Some(name) = name {
             ret.push_str("%");
@@ -576,7 +629,7 @@ impl<'a> InterfaceGenerator<'a> {
         ret.push_str(world_name);
         ret.push_str(" {\n");
 
-        #[derive(Arbitrary, Copy, Clone)]
+        #[derive(Arbitrary, Copy, Clone, Debug)]
         enum Direction {
             Import,
             Export,
@@ -615,6 +668,12 @@ impl<'a> InterfaceGenerator<'a> {
             };
 
             let mut part = String::new();
+
+            if let Some(annotation) = self.gen_feature_annotation(u)? {
+                part.push_str(&annotation);
+                part.push_str("\n");
+            }
+
             if let Some(dir) = direction {
                 part.push_str(match dir {
                     Direction::Import => "import ",
@@ -686,15 +745,14 @@ impl<'a> InterfaceGenerator<'a> {
                 }
                 ItemKind::AnonInterface(_) => {
                     let iface =
-                        InterfaceGenerator::new(self.generator, self.file, self.package_name)
+                        InterfaceGenerator::new(self.generator, self.file, self.package_name, None)
                             .gen_interface(u, None, Some(world_name))?;
                     part.push_str(&iface);
                 }
 
                 ItemKind::Type => {
                     let name = name.unwrap();
                     let (ty, typedef) = self.gen_typedef(u, &name)?;
-                    assert!(part.is_empty());
                     part = typedef;
                     let is_resource = ty.is_resource;
                     self.types_in_interface.push(ty);
@@ -803,20 +861,41 @@ impl<'a> InterfaceGenerator<'a> {
                 Item::Constructor if has_constructor => {}
                 Item::Constructor => {
                     has_constructor = true;
-                    let mut part = format!("constructor");
+                    let mut part = String::new();
+
+                    if let Some(annotation) = self.gen_feature_annotation(u)? {
+                        part.push_str(&annotation);
+                        part.push_str("\n");
+                    }
+
+                    part.push_str("constructor");
                     self.gen_params(u, &mut part, false)?;
                     part.push_str(";");
                     parts.push(part);
                 }
                 Item::Static => {
-                    let mut part = format!("%");
+                    let mut part = String::new();
+
+                    if let Some(annotation) = self.gen_feature_annotation(u)? {
+                        part.push_str(&annotation);
+                        part.push_str("\n");
+                    }
+
+                    part.push_str("%");
                     part.push_str(&gen_unique_name(u, &mut names)?);
                     part.push_str(": static ");
                     self.gen_func_sig(u, &mut part, false)?;
                     parts.push(part);
                 }
                 Item::Method => {
-                    let mut part = format!("%");
+                    let mut part = String::new();
+
+                    if let Some(annotation) = self.gen_feature_annotation(u)? {
+                        part.push_str(&annotation);
+                        part.push_str("\n");
+                    }
+
+                    part.push_str("%");
                     part.push_str(&gen_unique_name(u, &mut names)?);
                     part.push_str(": ");
                     self.gen_func_sig(u, &mut part, true)?;
@@ -840,6 +919,11 @@ impl<'a> InterfaceGenerator<'a> {
         part: &mut String,
         world_name: Option<&str>,
     ) -> Result<bool> {
+        if let Some(annotation) = self.gen_feature_annotation(u)? {
+            part.push_str(&annotation);
+            part.push_str("\n");
+        }
+
         let mut path = String::new();
         let (_name, _id, types) =
             match self.generator.gen_interface_path(u, self.file, &mut path)? {
@@ -893,6 +977,12 @@ impl<'a> InterfaceGenerator<'a> {
 
         let mut fuel = self.generator.config.max_type_size;
         let mut ret = String::new();
+
+        if let Some(annotation) = self.gen_feature_annotation(u)? {
+            ret.push_str(&annotation);
+            ret.push_str("\n");
+        }
+
         let mut is_resource = false;
         match u.arbitrary()? {
             Kind::Record => {
@@ -1148,7 +1238,14 @@ impl<'a> InterfaceGenerator<'a> {
     }
 
     fn gen_func(&mut self, u: &mut Unstructured<'_>) -> Result<String> {
-        let mut ret = "%".to_string();
+        let mut ret = String::new();
+
+        if let Some(annotation) = self.gen_feature_annotation(u)? {
+            ret.push_str(&annotation);
+            ret.push_str("\n");
+        }
+
+        ret.push_str("%");
         ret.push_str(&self.gen_unique_name(u)?);
         ret.push_str(": ");
         self.gen_func_sig(u, &mut ret, false)?;
@@ -1351,20 +1448,45 @@ impl File {
     }
 }
 
-fn gen_version(u: &mut Unstructured<'_>) -> Result<Version> {
-    Ok(Version {
-        major: u.int_in_range(0..=10)?,
-        minor: u.int_in_range(0..=10)?,
-        patch: u.int_in_range(0..=10)?,
-        pre: if u.arbitrary()? {
+fn gen_version_less_than(
+    u: &mut Unstructured<'_>,
+    existing_version: &Option<Version>,
+) -> Result<Version> {
+    const MAX_VERSION_RANGE: u64 = 10;
+    let (major, minor, patch) = match existing_version {
+        Some(v) => (v.major, v.minor, v.patch),
+        None => (MAX_VERSION_RANGE, MAX_VERSION_RANGE, MAX_VERSION_RANGE),
+    };
+
+    let new_version = Version {
+        major: u.int_in_range(0..=major)?,
+        minor: u.int_in_range(0..=minor)?,
+        patch: u.int_in_range(0..=patch)?,
+        pre: if (u.arbitrary()? && existing_version.is_none())
+            || existing_version.as_ref().is_some_and(|x| !x.pre.is_empty())
+        {
             semver::Prerelease::new("alpha.0").unwrap()
         } else {
             semver::Prerelease::EMPTY
         },
-        build: if u.arbitrary()? {
+        build: if (u.arbitrary()? && existing_version.is_none())
+            || existing_version
+                .as_ref()
+                .is_some_and(|x| !x.build.is_empty())
+        {
             semver::BuildMetadata::new("1.2.0").unwrap()
         } else {
             semver::BuildMetadata::EMPTY
         },
-    })
+    };
+
+    if let Some(v) = existing_version {
+        assert!(&new_version <= v, "{} <= {}", &new_version, v);
+    }
+
+    Ok(new_version)
+}
+
+fn gen_version(u: &mut Unstructured<'_>) -> Result<Version> {
+    gen_version_less_than(u, &None)
 }

crates/wit-smith/src/lib.rs

@@ -19,6 +19,7 @@ mod generate;
 pub fn smith(config: &Config, u: &mut Unstructured<'_>) -> Result<Vec<u8>> {
     let pkgs = generate::Generator::new(config.clone()).generate(u)?;
     let mut resolve = Resolve::default();
+    resolve.all_features = true;
     let mut last = None;
     for pkg in pkgs {
         let group = pkg.sources.parse().unwrap();

fuzz/src/roundtrip_wit.rs

@@ -126,6 +126,7 @@ fn roundtrip_through_printing(file: &str, resolve: &Resolve, pkg: PackageId, was
     // Print to a single string, using nested `package ... { .. }` statements,
     // and then parse that in a new `Resolve`.
     let mut new_resolve = Resolve::default();
+    new_resolve.all_features = true;
     let package_deps = resolve
         .packages
         .iter()