tests passing

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

Author: jsturtevant

Diff for: crates/wit-component/tests/merge/success/merge/foo.wit

@@ -54,11 +54,13 @@ world shared-world {
   export shared-items;
 }
 world shared-world-with-versions {
+  @since(version = 1.0.0)
   import shared-version-on-from;
   @since(version = 1.0.0)
   import shared-version-on-into;
 }
 world shared-world-with-versions-and-include {
+  @since(version = 1.0.0)
   import shared-version-on-from;
   @since(version = 1.0.0)
   import shared-version-on-into;

Diff for: crates/wit-parser/src/lib.rs

@@ -1079,7 +1079,7 @@ fn find_futures_and_streams(resolve: &Resolve, ty: Type, results: &mut Vec<TypeI
 ///
 /// This is added for WebAssembly/component-model#332 where @since and @unstable
 /// annotations were added to WIT.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde_derive::Deserialize, Serialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
 pub enum Stability {

Diff for: crates/wit-parser/src/resolve.rs

@@ -694,6 +694,41 @@ package {name} is defined in two different locations:\n\
             let new_id = match world_map.get(&id).copied() {
                 Some(id) => {
                     update_stability(&world.stability, &mut self.worlds[id].stability)?;
+                    for import in world.imports.iter() {
+                        match import.0 {
+                            WorldKey::Name(_) => {}
+                            key @ WorldKey::Interface(_) => {
+                                let name = |from_name: &WorldKey| -> WorldKey {
+                                    match from_name {
+                                        WorldKey::Name(s) => WorldKey::Name(s.clone()),
+                                        WorldKey::Interface(id) => WorldKey::Interface(
+                                            interface_map.get(id).copied().unwrap_or(*id),
+                                        ),
+                                    }
+                                };
+                                let newkey = name(key);
+                                if let Some(into_import) = self.worlds[id].imports.get_mut(&newkey)
+                                {
+                                    match (import.1, into_import) {
+                                        (
+                                            WorldItem::Interface {
+                                                id: _,
+                                                stability: astability,
+                                            },
+                                            WorldItem::Interface {
+                                                id: _,
+                                                stability: bstability,
+                                            },
+                                        ) => {
+                                            //assert_eq!(*aid, *bid);
+                                            merge_stability(astability, bstability)?;
+                                        }
+                                        _ => unreachable!(),
+                                    }
+                                }
+                            }
+                        }
+                    }
                     id
                 }
                 None => {
@@ -3404,13 +3439,20 @@ impl Remap {
                 let prev = items.entry(key.clone()).or_insert(item.1.clone());
                 match (&item.1, prev) {
                     (
-                        WorldItem::Interface { id: aid, .. },
-                        WorldItem::Interface { id: bid, .. },
+                        WorldItem::Interface {
+                            id: aid,
+                            stability: astability,
+                        },
+                        WorldItem::Interface {
+                            id: bid,
+                            stability: bstability,
+                        },
                     ) => {
                         // At this point in processing we care that the interfaces are the same
                         // but don't need to verify stability.  We've already confirmed that the interface should be
                         // apart of the component and versions/features are enabled so if they are the same it can be used.
                         assert_eq!(*aid, *bid);
+                        merge_stability(astability, bstability)?;
                     }
                     (WorldItem::Interface { .. }, _) => unreachable!(),
                     (WorldItem::Function(_), _) => unreachable!(),
@@ -3832,6 +3874,24 @@ fn update_stability(from: &Stability, into: &mut Stability) -> Result<()> {
     bail!("mismatch in stability from '{:?}' to '{:?}'", from, into)
 }
 
+fn merge_stability(from: &Stability, into: &mut Stability) -> Result<()> {
+    // If the two stability annotations are equal then
+    // there's nothing to do here.
+    if from == into {
+        return Ok(());
+    }
+
+    // if the from is higher elevate into
+    // note: enums defined at the top are lower than ones at the bottem
+    // stable is at the top so we are doing the opposite here.
+    if from < into {
+        *into = from.clone();
+        return Ok(());
+    }
+
+    return Ok(());
+}
+
 /// An error that can be returned during "world elaboration" during various
 /// [`Resolve`] operations.
 ///

Diff for: crates/wit-parser/tests/ui/gated-include-use-with-stable.wit.json

@@ -151,8 +151,8 @@
           "interface": {
             "id": 2,
             "stability": {
-              "unstable": {
-                "feature": "active"
+              "stable": {
+                "since": "0.2.0"
               }
             }
           }
@@ -205,7 +205,12 @@
         },
         "interface-1": {
           "interface": {
-            "id": 1
+            "id": 1,
+            "stability": {
+              "unstable": {
+                "feature": "active"
+              }
+            }
           }
         },
         "interface-0": {